dbg.*: dbg_net.c

"Fossies" - the Fresh Open Source Software Archive

Member "dbg-2.15.5/dbg_net.c" (21 Apr 2007, 12804 Bytes) of package /linux/www/old/dbg-2.15.5.tar.gz:

As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "dbg_net.c" see the Fossies "Dox" file reference documentation.

1 /*************************************************************************** 2 dbg_net.c - description 3 ------------------- 4 begin : Sun Sep 24 2000 5 copyright : (C) 2001 by Dmitri Dmitrienko 6 : (C) 2002, 2007 NuSphere Corp. 7 www : http://dd.cron.ru 8 : http://www.nusphere.com/ 9 author : written by Dmitri Dmitrienko 10 license : This source file is subject to version 3.0 of 11 the License, that is bundled with this package 12 in the file LICENSE, and is available at through 13 the world-wide-web at http://www.nusphere.com/dbg 14 ***************************************************************************/ 15 16 #ifdef HAVE_CONFIG_H 17 #include "config.h" 18 #endif 19 20 #ifdef DBG_USE_STDALLOCA 21 #define _MALLOC malloc 22 #define _FREE free 23 #else 24 #include "php.h" 25 #include "php_network.h" 26 #include "zend.h" 27 #include "zend_alloc.h" 28 #define _MALLOC emalloc 29 #define _FREE efree 30 #endif 31 32 33 34 #if PHP_WIN32 || defined WIN32 35 #if defined(ZEND_ENGINE_2) || defined(DBG_LISTENER) 36 #include <windows.h> 37 #include <winsock2.h> 38 #else 39 #include <winsock.h> 40 #endif 41 #else 42 #include <unistd.h> 43 #include <sys/socket.h> 44 #include <netinet/in.h> 45 #include <arpa/inet.h> 46 #include <netdb.h> 47 #include <sys/time.h> 48 #endif 49 50 51 #include "dbg_net.h" 52 #include <string.h> 53 #include <signal.h> 54 #include <errno.h> 55 #include <stdlib.h> 56 #include <stdarg.h> 57 #include <stdio.h> 58 59 #ifdef __cplusplus 60 extern "C"{ 61 #endif 62 63 DBGAPI int dbg_packet_new(dbg_packet *pack) { 64 memset(pack,0,sizeof(dbg_packet)); 65 return 1; 66 } 67 68 DBGAPI void dbg_packet_free(dbg_packet *pack) { 69 if (pack->buf) _FREE(pack->buf); 70 memset(pack,0,sizeof(dbg_packet)); 71 } 72 73 DBGAPI void dbg_packet_clear(dbg_packet *pack) { 74 pack->size = 0; 75 pack->lastrawid = 0; 76 } 77 78 int dbg_packet_update_limit(dbg_packet *pack, int space) { 79 int alimit; 80 void *p; 81 82 if (!pack->limit) { 83 alimit = PACKET_LIMIT_ROUND(space); 84 pack->size = 0; 85 pack->buf = _MALLOC(alimit); 86 if (!pack->buf) return 0; 87 pack->limit = alimit; 88 } else if (pack->limit < (pack->size + space)) { 89 alimit = PACKET_LIMIT_ROUND(pack->size + space); 90 p = _MALLOC(alimit); 91 if (!p) return 0; 92 memcpy(p, pack->buf, pack->size); 93 _FREE(pack->buf); 94 pack->buf = p; 95 pack->limit = alimit; 96 } 97 return 1; 98 } 99 100 DBGAPI int dbg_packet_add_frame(dbg_packet *pack, framename frname, void *data, int datasize) { 101 dbg_frame *p; 102 int asize; 103 104 datasize = ALIGN8(datasize); 105 asize = datasize + sizeof(dbg_frame); 106 if (!dbg_packet_update_limit(pack, asize)) { 107 return 0; 108 } 109 p = (dbg_frame *) ((char *) (pack->buf) + pack->size); 110 p->size = datasize; 111 p->name = frname; 112 113 if (data) memcpy(FRAME_DATA_PTR(char,p), data, datasize); 114 pack->size += asize; 115 return FRAME_DATA_PTR(char,p) - (char*)pack->buf; 116 } 117 118 int dbg_sock_read(char *buf, int bufsize, int socket, int timeoutms) { 119 fd_set rset, eset; 120 struct timeval timeout; 121 int ret_val; 122 123 if (socket <= 0) { 124 return 0; 125 } 126 127 FD_ZERO(&rset); 128 FD_SET((unsigned int)socket, &rset); 129 FD_ZERO(&eset); 130 FD_SET((unsigned int)socket, &eset); 131 if (timeoutms >= 0) { 132 timeout.tv_sec = timeoutms / 1000; 133 timeout.tv_usec = (timeoutms>1000) ? 0 : timeoutms * 1000; 134 } else { 135 timeout.tv_sec = 0; 136 timeout.tv_usec = 0; 137 } 138 139 do { 140 ret_val = select(socket + 1, &rset, NULL, &eset, &timeout); 141 } while (ret_val == -1 && errno == EINTR); 142 143 if (ret_val != 1 || !FD_ISSET((unsigned int)socket, &rset)) { 144 return ((ret_val < 0) ? (-1) : (0)); 145 } 146 147 if (ret_val >= 0) { 148 ret_val = SREAD(socket, buf, bufsize); 149 if (ret_val == 0) return (-1); /* most probably peer has been terminated */ 150 } 151 return (ret_val); 152 } 153 154 DBGAPI dbg_frame *dbg_packet_firstframe(dbg_packet *pack) { 155 return (pack->size ? (pack->buf):(NULL)); 156 } 157 158 DBGAPI dbg_frame *dbg_packet_nextframe(dbg_packet *pack, dbg_frame *frame) { 159 dbg_frame *p; 160 int s; 161 162 #ifdef _DEBUG 163 int frsize; 164 char is_eq; 165 166 p = pack->buf; 167 s = pack->size; 168 while (s >= sizeof(dbg_frame)) { 169 frsize = p->size + sizeof(dbg_frame); 170 is_eq = (p == frame); 171 p = (dbg_frame *)((char *)p + frsize); 172 s -= frsize; 173 if (is_eq) { 174 if (s < sizeof(dbg_frame)) return NULL; 175 return p; 176 } 177 } 178 return NULL; 179 #else 180 p = frame; 181 s = pack->size - ((char*)frame + frame->size + sizeof(dbg_frame) - (char*)pack->buf); 182 if (s >= sizeof(dbg_frame)) { 183 p = (dbg_frame *)((char *) p + p->size + sizeof(dbg_frame)); 184 return p; 185 } 186 return NULL; 187 #endif 188 } 189 190 DBGAPI dbg_frame* dbg_packet_findfirstframe(dbg_packet *pack, framename frname) { 191 dbg_frame *p; 192 int s,frsize; 193 194 s = pack->size; 195 p = pack->buf; 196 while (s >= sizeof(dbg_frame)) { 197 if (p->name == frname) { 198 return p; 199 } 200 frsize = p->size + sizeof(dbg_frame); 201 p =(dbg_frame *)((char *)p + frsize); 202 s -= frsize; 203 } 204 return NULL; 205 } 206 207 DBGAPI dbg_frame* dbg_packet_findnextframe(dbg_packet *pack, framename frname, dbg_frame *frame) { 208 dbg_frame *p; 209 int s,frsize; 210 211 p = dbg_packet_nextframe(pack, frame); 212 213 s = (p) ? pack->size - ((char*)p - (char*)pack->buf) : 0; 214 while (s >= sizeof(dbg_frame)) { 215 if (p->name == frname) { 216 return p; 217 } 218 frsize = p->size + sizeof(dbg_frame); 219 p = (dbg_frame *) ((char *)p + frsize); 220 s -= frsize; 221 } 222 return NULL; 223 } 224 225 DBGAPI int dbg_packet_send(int cmd , dbg_packet *pack, int socket, int flags) { 226 dbg_header_struct *packetbuf; 227 dbg_frame *p; 228 int packsize, frsize, *v, i; 229 int ret_val, sz, tosend, chunksz, sentsz, icnt; 230 char *pchunk; 231 232 if (socket <= 0) { 233 return -1; 234 } 235 packsize = sizeof(dbg_header_struct) + ((pack!=NULL)? pack->size:0); 236 if (!(packetbuf = _MALLOC(packsize))) { 237 return 0; 238 } 239 packetbuf->sync = htonl(DBG_SYNC); 240 packetbuf->cmd = htonl(cmd); 241 packetbuf->flags = htonl(flags); 242 packetbuf->bodysize = htonl(pack!=NULL?pack->size:0); 243 if (pack && pack->size) { 244 p = (dbg_frame*)((char *)packetbuf + sizeof(dbg_header_struct)); 245 sz = pack->size; 246 memcpy(p, pack->buf, pack->size); /* copy data */ 247 while (sz > 0) { 248 if (p->name != FRAME_RAWDATA) { 249 v = (int *)((char *)p + sizeof(*p)); 250 icnt = p->size / (int)sizeof(*v); 251 for (i=0; i < icnt; i++) { 252 *v = htonl(*v); 253 v++; 254 } 255 } else { 256 dbg_rawdata_body *body = FRAME_DATA_PTR(dbg_rawdata_body, p); 257 body->datasize = htonl(body->datasize); 258 body->rawid = htonl(body->rawid); 259 } 260 frsize = p->size + sizeof(dbg_frame); 261 p->size = htonl(p->size); 262 p->name = htonl(p->name); 263 p = (dbg_frame *)((char *)p + frsize); 264 sz-=frsize; 265 } 266 } 267 tosend = packsize; 268 pchunk = (char *)packetbuf; 269 sentsz = 0; 270 ret_val = 0; 271 while (tosend > 0) { 272 chunksz = (tosend > CHUNKSIZE) ? CHUNKSIZE:tosend; 273 ret_val = SSEND(socket, pchunk, chunksz); 274 if (ret_val <= 0) break; 275 sentsz+=ret_val; 276 pchunk+=ret_val; 277 tosend-=ret_val; 278 } 279 _FREE(packetbuf); 280 if (ret_val < 0) return -1; 281 if (sentsz == packsize) return sentsz; 282 return 0; 283 } 284 285 int dbg_packet_recv_body(dbg_packet *pack, int bodysize, int socket, int timeoutms) { 286 dbg_frame *p; 287 int *v, i; 288 int ret_val = 0; 289 int restsize, chunksz, recvsz, is_first, icnt; 290 int frsize; 291 char *pchunk; 292 293 if (!dbg_packet_update_limit(pack, bodysize)) { 294 return 0; 295 } 296 pchunk = (char *) (pack->buf) + pack->size; 297 restsize = bodysize; 298 recvsz = 0; 299 is_first = 1; 300 while (restsize > 0) { 301 if (is_first) { 302 chunksz = (restsize>(CHUNKSIZE-sizeof(dbg_header_struct))) ? CHUNKSIZE-sizeof(dbg_header_struct):restsize; 303 is_first = 0; 304 } 305 else { 306 chunksz = (restsize>CHUNKSIZE) ? CHUNKSIZE:restsize; 307 } 308 ret_val = dbg_sock_read(pchunk, chunksz, socket, timeoutms); 309 if (ret_val < 0 || (recvsz == 0 && ret_val == 0)) 310 break; 311 restsize -= ret_val; 312 recvsz += ret_val; 313 pchunk += ret_val; 314 } 315 if (recvsz!=bodysize) { 316 dbg_packet_clear(pack); 317 if (ret_val < 0) return -1; 318 return 0; 319 } 320 p = (dbg_frame *)((char *) (pack->buf) + pack->size); 321 restsize = bodysize; 322 while (restsize > 0) { 323 p->size = ntohl(p->size); 324 p->name = ntohl(p->name); 325 if (p->name != FRAME_RAWDATA) { /* make all ints back system-depended Big- or Little- Endian*/ 326 v = (int *)((char *)p + sizeof(*p)); 327 icnt = p->size/(int)sizeof(*v); 328 for (i=0; i < icnt; i++) { 329 *v = ntohl(*v); 330 v++; 331 } 332 } else { 333 dbg_rawdata_body *body = FRAME_DATA_PTR(dbg_rawdata_body,p); 334 body->datasize = ntohl(body->datasize); 335 body->rawid = ntohl(body->rawid); 336 } 337 frsize = p->size + (int)sizeof(dbg_frame); 338 if ((p->size > MAX_PACKET_SIZE) || (frsize > restsize)) { 339 dbg_packet_clear(pack); 340 return 0; 341 } 342 p = (dbg_frame *)((char *)p + frsize); 343 restsize -= frsize; 344 if (restsize < 0) { 345 dbg_packet_clear(pack); 346 return 0; 347 } 348 } 349 pack->size += bodysize; 350 return bodysize; 351 } 352 353 DBGAPI int dbg_packet_recv(dbg_header_struct *hdr, dbg_packet *pack, int socket, int timeoutms) { 354 int ret_val; 355 356 if (!pack || !hdr) return 0; 357 dbg_packet_clear(pack); 358 ret_val = dbg_sock_read((char *) hdr, sizeof(dbg_header_struct), socket, timeoutms); 359 if ((ret_val != sizeof(dbg_header_struct)) || 360 (hdr->sync != (int)ntohl(DBG_SYNC))) { 361 memset(hdr,0,sizeof(dbg_header_struct)); 362 if (ret_val < 0) return -1; 363 return 0; 364 } 365 366 hdr->bodysize = ntohl(hdr->bodysize); 367 hdr->cmd = ntohl(hdr->cmd); 368 hdr->flags = ntohl(hdr->flags); 369 370 if ((hdr->bodysize<0) || (hdr->bodysize > MAX_PACKET_SIZE)) { 371 memset(hdr,0,sizeof(dbg_header_struct)); 372 return 0; 373 } 374 if (hdr->bodysize) { 375 if (!dbg_packet_recv_body(pack, hdr->bodysize, socket, timeoutms)) { 376 memset(hdr,0,sizeof(dbg_header_struct)); 377 return 0; 378 } 379 } 380 return hdr->bodysize + sizeof(dbg_header_struct); 381 } 382 383 384 int add_rawdata(dbg_packet *pack, const char *data, int datasize, char **presult) { 385 dbg_rawdata_body *body; 386 char *p; 387 int id, bodyofs; 388 389 if (presult) *presult = NULL; 390 if (!data && datasize) return 0; 391 bodyofs = dbg_packet_add_frame(pack, FRAME_RAWDATA, NULL, datasize + sizeof(dbg_rawdata_body)); 392 if (!bodyofs) { 393 return 0; 394 } 395 id = ++pack->lastrawid; 396 body = (dbg_rawdata_body *)((char *)pack->buf + bodyofs); 397 body->rawid = id; 398 body->datasize = datasize; 399 p = (char*)body + sizeof(dbg_rawdata_body); 400 if (presult) *presult = p; 401 if (data) memcpy(p, data, datasize); 402 403 return id; 404 } 405 406 407 DBGAPI int dbg_packet_add_rawdata(dbg_packet *pack, const char *data, int datasize) { 408 return add_rawdata(pack, data, datasize, NULL); 409 } 410 411 DBGAPI int dbg_packet_add_stringlen(dbg_packet *pack, const char *str, int len) { 412 char *rslt; 413 int ret_val; 414 415 if (len == 0) return 0; 416 ret_val = add_rawdata(pack, str, len+1, &rslt); 417 if (rslt && ret_val) { 418 rslt[len]='\0'; 419 } 420 return ret_val; 421 } 422 423 424 DBGAPI int dbg_packet_findrawdata(dbg_packet *pack, int rawid, char **data, int *datasize) { 425 dbg_frame *fr; 426 dbg_rawdata_body *body; 427 428 *datasize = 0; 429 *data = NULL; 430 if (rawid <= 0) return 0; 431 fr = dbg_packet_findfirstframe(pack, FRAME_RAWDATA); 432 while (fr) { 433 body = FRAME_DATA_PTR(dbg_rawdata_body,fr); 434 if ((int)body->rawid == rawid) { 435 *data = (char*)body + sizeof(dbg_rawdata_body); 436 *datasize = body->datasize; 437 return sizeof(dbg_rawdata_body) + (*datasize); 438 } 439 fr = dbg_packet_findnextframe(pack, FRAME_RAWDATA, fr); 440 } 441 return 0; 442 } 443 444 445 446 447 448 449 /********************************\ 450 451 DEBUGGING/TRACING\FACILITY 452 453 \********************************/ 454 455 #if defined(DBG_TRACEFILE) 456 #ifdef WIN32 457 #define OPENLOG(f) f = fopen(DBG_TRACEFILE,"a+") 458 #else 459 #define OPENLOG(f) f = fopen(DBG_TRACEFILE,"a") 460 #endif 461 462 #define LOG(msg) { \ 463 FILE *log; \ 464 OPENLOG(log); \ 465 if (log) { \ 466 fprintf(log, "%s", msg); \ 467 fclose(log); \ 468 } \ 469 } 470 #else 471 #define LOG(msg) 472 #endif 473 474 475 void SysError(const char *msg,...) { 476 va_list args; 477 char buf[512]; 478 479 va_start(args, msg); 480 vsnprintf(buf, sizeof(buf)-1, msg, args); 481 va_end(args); 482 483 fprintf(stderr, buf); 484 485 #ifdef WIN32 486 { 487 int err; 488 err = WSAGetLastError(); 489 if (err) { 490 int i; 491 FormatMessage( 492 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 493 NULL, 494 err, 495 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ 496 buf, 497 sizeof(buf), 498 NULL 499 ); 500 i=strlen(buf); 501 while (--i>0 && buf[i]<32); 502 buf[i+1] = 0; 503 fprintf(stderr, "\nOSERR:%d:\"%s\"\n", err, buf); 504 DBG_TRACE(("OSERR: %d \"%s\"\n", err, buf)); 505 } 506 } 507 #else 508 if (errno) { 509 fprintf(stderr, "\nOSERR:%d:\"%s\"\n", errno, strerror(errno)); 510 DBG_TRACE(("OSERR: %d \"%s\"\n", errno, buf)); 511 } 512 #endif 513 } 514 515 /************************ 516 517 TRACE 518 519 *************************/ 520 521 522 #ifdef DBG_DEBUG 523 void _dbg_trace(const char *str,...) { 524 va_list args; 525 char buf[1024]; 526 527 if (!str) return; 528 va_start(args, str); 529 vsnprintf(buf, sizeof(buf)-1, str, args); 530 #ifdef PHP_WIN32 531 OutputDebugString("[DBG] "); 532 OutputDebugString(buf); 533 #endif 534 LOG(buf); 535 fprintf(stderr, "[DBG] "); 536 fprintf(stderr, buf); 537 va_end(args); 538 } 539 #endif 540 541 #ifdef __cplusplus 542 } 543 #endif