/* Connect to the server specified by uuu->net_info, then compose and form * relevant HTTP header, and flush the accumulated output data(uuu->w_buf) * after the HTTP header. If connection/write unsuccessful, retry to reconnect * and send the data again until permitted by s_Adjust(). */ static EIO_Status s_ConnectAndSend(SHttpConnector* uuu, EReadMode read_mode) { EIO_Status status; for (;;) { char* null = 0; if (!uuu->sock) { if ((status = s_Connect(uuu, read_mode)) != eIO_Success) break; assert(uuu->sock); uuu->read_header = 1/*true*/; uuu->shut_down = 0/*false*/; uuu->expected = 0; uuu->received = 0; uuu->code = 0; } else status = eIO_Success; if (uuu->w_len) { size_t off = BUF_Size(uuu->w_buf) - uuu->w_len; SOCK_SetTimeout(uuu->sock, eIO_Write, uuu->w_timeout); do { char buf[4096]; size_t n_written; size_t n_write = BUF_PeekAt(uuu->w_buf, off, buf, sizeof(buf)); status = SOCK_Write(uuu->sock, buf, n_write, &n_written, eIO_WritePlain); if (status != eIO_Success) break; uuu->w_len -= n_written; off += n_written; } while (uuu->w_len); } else if (!uuu->shut_down) status = SOCK_Write(uuu->sock, 0, 0, 0, eIO_WritePlain); if (status == eIO_Success) { assert(uuu->w_len == 0); if (!uuu->shut_down) { /* 10/07/03: While this call here is perfectly legal, it could * cause connection severed by a buggy CISCO load-balancer. */ /* 10/28/03: CISCO's beta patch for their LB shows that the * problem has been fixed; no more 2'30" drops in connections * that shut down for write. We still leave this commented * out to allow unpatched clients to work seamlessly... */ /*SOCK_Shutdown(uuu->sock, eIO_Write);*/ uuu->shut_down = 1; } break; } if (status == eIO_Timeout && uuu->w_timeout && !(uuu->w_timeout->sec | uuu->w_timeout->usec)) { break; } CORE_LOGF_X(6, eLOG_Error, ("[HTTP] Error writing body at offset %lu (%s)", (unsigned long)(BUF_Size(uuu->w_buf) - uuu->w_len), IO_StatusStr(status))); /* write failed; close and try to use another server */ SOCK_Abort(uuu->sock); s_DropConnection(uuu, 0/*no wait*/); if (!s_Adjust(uuu, &null, read_mode)) { uuu->can_connect = eCC_None; status = eIO_Closed; break; } } return status; }
extern int main(void) { # define X_MAX_N_IO (unsigned) 4 # define X_MAX_READ (size_t) (3 * BUF_DEF_CHUNK_SIZE) # define X_TIMES (unsigned) (s_Rand() % X_MAX_N_IO) # define X_BYTES (size_t) (s_Rand() % X_MAX_READ) BUF buf = 0; BUF buf1 = 0; int/*bool*/ do_loop = 1 /* true */; /* a simple test */ {{ char charbuf[128]; assert(BUF_PushBack(&buf, (const char*) "0", 1)); assert(BUF_Write(&buf, (const char*) "1", 1)); assert(BUF_Peek(buf, charbuf, sizeof(charbuf)) == 2); assert(BUF_PushBack(&buf, (const char*) "BB", 2)); assert(BUF_PushBack(&buf, (const char*) "aa", 2)); assert(BUF_Write(&buf, (const char*) "23\0", 3)); assert(BUF_Read(buf, charbuf, sizeof(charbuf)) == 9); assert(strcmp(charbuf, (const char*) "aaBB0123") == 0); assert(BUF_Prepend(&buf, "Hello World\0", 12)); assert(BUF_Read(buf, 0, 6) == 6); assert(BUF_PushBack(&buf, "Goodbye ", 8)); assert(BUF_Read(buf, charbuf, sizeof(charbuf)) == 14); assert(strcmp(charbuf, (const char*) "Goodbye World") == 0); BUF_Destroy(buf); buf = 0; }} /* usage */ fprintf(stderr, "Waiting for the data in STDIN...\n"); /* read up to the very end of input stream */ while ( do_loop ) { char charbuf[X_MAX_READ]; unsigned i, n_times; /* read from the input stream, write to the NCBI IO-buf */ n_times = X_TIMES; for (i = 0; i < n_times; i++) { size_t n_bytes = X_BYTES; if ( !n_bytes ) continue; n_bytes = fread(charbuf, 1, n_bytes, stdin); fprintf(stderr, "STDIN %5lu\n", (unsigned long) n_bytes); if ( !n_bytes ) { do_loop = 0 /* false */; /* end of the input stream */ break; } assert(BUF_Write(&buf, charbuf, n_bytes)); assert(BUF_Write(&buf1, charbuf, n_bytes)); fprintf(stderr, "BUF_Write %5lu\n", (unsigned long) n_bytes); } /* peek & read from the NCBI IO-buf, write to the output stream */ n_times = X_TIMES; for (i = 0; i < n_times && BUF_Size(buf); i++) { int/*bool*/ do_peek = (s_Rand() % 2 == 0); size_t n_peek = 0; size_t n_bytes = X_BYTES; if ( !n_bytes ) continue; /* peek from the NCBI IO-buf */ if ( do_peek ) { unsigned j, n_peek_times = s_Rand() % 3 + 1; for (j = 0; j < n_peek_times; j++) { n_peek = BUF_Peek(buf, charbuf, n_bytes); fprintf(stderr, "\tBUF_Peek %5lu\n",(unsigned long)n_peek); } } /* read (or just discard) the data */ if (do_peek && s_Rand() % 2 == 0) n_bytes = BUF_Read(buf, 0, n_bytes); else n_bytes = BUF_Read(buf, charbuf, n_bytes); fprintf(stderr, "\t\tBUF_Read %5lu\n", (unsigned long) n_bytes); assert(!do_peek || n_bytes == n_peek); /* push back & re-read */ if (s_Rand() % 3 == 0) { size_t n_pushback = s_Rand() % n_bytes; if (n_pushback == 0) n_pushback = 1; assert(BUF_PushBack (&buf, charbuf + n_bytes - n_pushback, n_pushback)); assert(BUF_Read ( buf, charbuf + n_bytes - n_pushback, n_pushback)); } /* write the read data to the output stream */ assert(n_bytes == fwrite(charbuf, 1, n_bytes, stdout)); fprintf(stderr, "\t\tSTDOUT %5lu\n", (unsigned long) n_bytes); } } /* flush the IO-buf to the output stream */ while ( BUF_Size(buf) ) { char charbuf[256]; size_t n_bytes = BUF_Read(buf, charbuf, sizeof(charbuf)); {{ char tmp[sizeof(charbuf)]; size_t n_pushback = s_Rand() % 64; if (n_pushback > n_bytes) n_pushback = n_bytes; assert(BUF_PushBack (&buf, charbuf + n_bytes - n_pushback, n_pushback)); assert(BUF_Read ( buf, tmp, n_pushback) == n_pushback); memcpy(charbuf + n_bytes - n_pushback, tmp, n_pushback); }} fprintf(stderr, "\t\tBUF_Read/flush %5lu\n", (unsigned long) n_bytes); assert(n_bytes); assert(n_bytes == fwrite(charbuf, 1, n_bytes, stdout)); fprintf(stderr, "\t\tSTDOUT /flush %5lu\n", (unsigned long) n_bytes); } fflush(stdout); /* Test for "BUF_PeekAt()" */ {{ size_t buf1_size = BUF_Size(buf1); int n; assert(buf1_size > 0); for (n = 0; n < 20; n++) { size_t pos; size_t size; /* Erratically copy "buf1" to "buf" */ for (pos = 0; pos < buf1_size; pos += size) { char temp_buf[BUF_DEF_CHUNK_SIZE * 2]; size_t n_peeked; size = s_Rand() % (BUF_DEF_CHUNK_SIZE * 2); n_peeked = BUF_PeekAt(buf1, pos, temp_buf, size); if (pos + size <= buf1_size) { assert(n_peeked == size); } else { assert(n_peeked == buf1_size - pos); } assert(BUF_PeekAt(buf1, pos, temp_buf, size) == n_peeked); assert(BUF_Write(&buf, temp_buf, n_peeked)); } /* Compare "buf" and "buf1"; empty up "buf" in process */ assert(BUF_Size(buf1) == BUF_Size(buf)); for (pos = 0; pos < buf1_size; pos += size) { char bb[1024]; char b1[1024]; assert(sizeof(bb) == sizeof(b1)); size = BUF_Read(buf, bb, sizeof(bb)); assert(BUF_PeekAt(buf1, pos, b1, size) == size); assert(size <= sizeof(b1)); assert(memcmp(bb, b1, size) == 0); } assert(pos == buf1_size); assert(BUF_Size(buf1) == buf1_size); assert(BUF_Size(buf) == 0); } }} /* cleanup & exit */ BUF_Destroy(buf1); BUF_Destroy(buf); return 0; }