void buffer_append_string_buffer(buffer *b, const buffer *src) { if (NULL == src) { buffer_append_string_len(b, NULL, 0); } else { buffer_append_string_len(b, src->ptr, buffer_string_length(src)); } }
static void mod_authn_gssapi_log_gss_error(server *srv, const char *file, unsigned int line, const char *func, const char *extra, OM_uint32 err_maj, OM_uint32 err_min) { buffer * const msg = buffer_init_string(func); OM_uint32 maj_stat, min_stat; OM_uint32 msg_ctx = 0; gss_buffer_desc status_string; buffer_append_string_len(msg, CONST_STR_LEN("(")); if (extra) buffer_append_string(msg, extra); buffer_append_string_len(msg, CONST_STR_LEN("):")); do { maj_stat = gss_display_status(&min_stat, err_maj, GSS_C_GSS_CODE, GSS_C_NO_OID, &msg_ctx, &status_string); if (GSS_ERROR(maj_stat)) break; buffer_append_string(msg, status_string.value); gss_release_buffer(&min_stat, &status_string); maj_stat = gss_display_status(&min_stat, err_min, GSS_C_MECH_CODE, GSS_C_NULL_OID, &msg_ctx, &status_string); if (!GSS_ERROR(maj_stat)) { buffer_append_string(msg, " ("); buffer_append_string(msg, status_string.value); buffer_append_string(msg, ")"); gss_release_buffer(&min_stat, &status_string); } } while (!GSS_ERROR(maj_stat) && msg_ctx != 0); log_error_write(srv, file, line, "b", msg); buffer_free(msg); }
static void http_list_directory_include_file(buffer *out, buffer *path, const char *classname, int encode) { int fd = open(path->ptr, O_RDONLY | FIFO_NONBLOCK); ssize_t rd; char buf[8192]; if (-1 == fd) return; if (encode) { buffer_append_string_len(out, CONST_STR_LEN("<pre class=\"")); buffer_append_string(out, classname); buffer_append_string_len(out, CONST_STR_LEN("\">")); } while ((rd = read(fd, buf, sizeof(buf))) > 0) { if (encode) { buffer_append_string_encoded(out, buf, (size_t)rd, ENCODING_MINIMAL_XML); } else { buffer_append_string_len(out, buf, (size_t)rd); } } close(fd); if (encode) { buffer_append_string_len(out, CONST_STR_LEN("</pre>")); } }
static handler_t mod_status_handle_server_statistics(server *srv, connection *con, void *p_d) { buffer *b; size_t i; array *st = srv->status; UNUSED(p_d); if (0 == st->used) { /* we have nothing to send */ con->http_status = 204; con->file_finished = 1; return HANDLER_FINISHED; } b = buffer_init(); for (i = 0; i < st->used; i++) { size_t ndx = st->sorted[i]; buffer_append_string_buffer(b, st->data[ndx]->key); buffer_append_string_len(b, CONST_STR_LEN(": ")); buffer_append_int(b, ((data_integer *)(st->data[ndx]))->value); buffer_append_string_len(b, CONST_STR_LEN("\n")); } chunkqueue_append_buffer(con->write_queue, b); buffer_free(b); response_header_overwrite(srv, con, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/plain")); con->http_status = 200; con->file_finished = 1; return HANDLER_FINISHED; }
static int log_buffer_prepare(buffer *b, server *srv, const char *filename, unsigned int line) { switch(srv->errorlog_mode) { case ERRORLOG_PIPE: case ERRORLOG_FILE: case ERRORLOG_FD: if (-1 == srv->errorlog_fd) return -1; /* cache the generated timestamp */ if (srv->cur_ts != srv->last_generated_debug_ts) { buffer_string_prepare_copy(srv->ts_debug_str, 255); buffer_append_strftime(srv->ts_debug_str, "%Y-%m-%d %H:%M:%S", localtime(&(srv->cur_ts))); srv->last_generated_debug_ts = srv->cur_ts; } buffer_copy_buffer(b, srv->ts_debug_str); buffer_append_string_len(b, CONST_STR_LEN(": (")); break; case ERRORLOG_SYSLOG: /* syslog is generating its own timestamps */ buffer_copy_string_len(b, CONST_STR_LEN("(")); break; } buffer_append_string(b, filename); buffer_append_string_len(b, CONST_STR_LEN(".")); buffer_append_int(b, line); buffer_append_string_len(b, CONST_STR_LEN(") ")); return 0; }
static void accesslog_append_escaped(buffer *dest, buffer *str) { char *ptr, *start, *end; /* replaces non-printable chars with \xHH where HH is the hex representation of the byte */ /* exceptions: " => \", \ => \\, whitespace chars => \n \t etc. */ if (buffer_string_is_empty(str)) return; buffer_string_prepare_append(dest, buffer_string_length(str)); for (ptr = start = str->ptr, end = str->ptr + buffer_string_length(str); ptr < end; ptr++) { unsigned char const c = (unsigned char) *ptr; if (c >= ' ' && c <= '~' && c != '"' && c != '\\') { /* nothing to change, add later as one block */ } else { /* copy previous part */ if (start < ptr) { buffer_append_string_len(dest, start, ptr - start); } start = ptr + 1; switch (c) { case '"': BUFFER_APPEND_STRING_CONST(dest, "\\\""); break; case '\\': BUFFER_APPEND_STRING_CONST(dest, "\\\\"); break; case '\b': BUFFER_APPEND_STRING_CONST(dest, "\\b"); break; case '\n': BUFFER_APPEND_STRING_CONST(dest, "\\n"); break; case '\r': BUFFER_APPEND_STRING_CONST(dest, "\\r"); break; case '\t': BUFFER_APPEND_STRING_CONST(dest, "\\t"); break; case '\v': BUFFER_APPEND_STRING_CONST(dest, "\\v"); break; default: { /* non printable char => \xHH */ char hh[5] = {'\\','x',0,0,0}; char h = c / 16; hh[2] = (h > 9) ? (h - 10 + 'A') : (h + '0'); h = c % 16; hh[3] = (h > 9) ? (h - 10 + 'A') : (h + '0'); buffer_append_string_len(dest, &hh[0], 4); } break; } } } if (start < end) { buffer_append_string_len(dest, start, end - start); } }
static int proxy_create_env(server *srv, handler_ctx *hctx) { size_t i; connection *con = hctx->remote_conn; buffer *b; /* build header */ b = buffer_init(); /* request line */ buffer_copy_string(b, get_http_method_name(con->request.http_method)); buffer_append_string_len(b, CONST_STR_LEN(" ")); buffer_append_string_buffer(b, con->request.uri); buffer_append_string_len(b, CONST_STR_LEN(" HTTP/1.0\r\n")); proxy_append_header(con, "X-Forwarded-For", (char *)inet_ntop_cache_get_ip(srv, &(con->dst_addr))); /* http_host is NOT is just a pointer to a buffer * which is NULL if it is not set */ if (!buffer_string_is_empty(con->request.http_host)) { proxy_set_header(con, "X-Host", con->request.http_host->ptr); } proxy_set_header(con, "X-Forwarded-Proto", con->uri.scheme->ptr); /* request header */ for (i = 0; i < con->request.headers->used; i++) { data_string *ds; ds = (data_string *)con->request.headers->data[i]; if (!buffer_is_empty(ds->value) && !buffer_is_empty(ds->key)) { if (buffer_is_equal_string(ds->key, CONST_STR_LEN("Connection"))) continue; if (buffer_is_equal_string(ds->key, CONST_STR_LEN("Proxy-Connection"))) continue; buffer_append_string_buffer(b, ds->key); buffer_append_string_len(b, CONST_STR_LEN(": ")); buffer_append_string_buffer(b, ds->value); buffer_append_string_len(b, CONST_STR_LEN("\r\n")); } } buffer_append_string_len(b, CONST_STR_LEN("\r\n")); hctx->wb->bytes_in += buffer_string_length(b); chunkqueue_append_buffer(hctx->wb, b); buffer_free(b); /* body */ if (con->request.content_length) { chunkqueue *req_cq = con->request_content_queue; chunkqueue_steal(hctx->wb, req_cq, req_cq->bytes_in); } return 0; }
static int mod_status_header_append(buffer *b, const char *key) { buffer_append_string_len(b, CONST_STR_LEN(" <tr>\n")); buffer_append_string_len(b, CONST_STR_LEN(" <th colspan=\"2\">")); buffer_append_string(b, key); buffer_append_string_len(b, CONST_STR_LEN("</th>\n")); buffer_append_string_len(b, CONST_STR_LEN(" </tr>\n")); return 0; }
static int fastcgi_get_packet(fastcgiResponse *fr, fastcgi_response_packet *packet) { size_t offset; size_t toread; FCGI_Header *header; packet->b = buffer_init(); packet->len = 0; packet->type = 0; packet->padding = 0; packet->request_id = 0; toread = 8; buffer_append_string_len(packet->b, fr->buf->ptr + fr->offset, toread); if ((packet->b->used == 0) || (packet->b->used - 1 < sizeof(FCGI_Header))) { /* no header */ buffer_free(packet->b); return -1; } /* we have at least a header, now check how much me have to fetch */ header = (FCGI_Header *)(packet->b->ptr); packet->len = (header->contentLengthB0 | (header->contentLengthB1 << 8)) + header->paddingLength; packet->request_id = (header->requestIdB0 | (header->requestIdB1 << 8)); packet->type = header->type; packet->padding = header->paddingLength; /* ->b should only be the content */ buffer_copy_string_len(packet->b, CONST_STR_LEN("")); /* used == 1 */ if (packet->len) { /* copy the content */ buffer_append_string_len(packet->b, fr->buf->ptr + fr->offset + toread, packet->len); if (packet->b->used < packet->len + 1) { /* we didn't get the full packet */ buffer_free(packet->b); return -1; } packet->b->used -= packet->padding; packet->b->ptr[packet->b->used - 1] = '\0'; } /* tag the chunks as read */ toread = packet->len + sizeof(FCGI_Header); fr->offset += toread; return 0; }
int response_header_append(server *srv, connection *con, const char *key, size_t keylen, const char *value, size_t vallen) { data_string *ds; UNUSED(srv); /* if there already is a key by this name append the value */ if (NULL != (ds = (data_string *)array_get_element(con->response.headers, key))) { buffer_append_string_len(ds->value, CONST_STR_LEN(", ")); buffer_append_string_len(ds->value, value, vallen); return 0; } return response_header_insert(srv, con, key, keylen, value, vallen); }
static void http_dirlist_append_js_table_resort (buffer *b, connection *con) { char col = '0'; char ascending = '0'; if (!buffer_string_is_empty(con->uri.query)) { const char *qs = con->uri.query->ptr; do { if (qs[0] == 'C' && qs[1] == '=') { switch (qs[2]) { case 'N': col = '0'; break; case 'M': col = '1'; break; case 'S': col = '2'; break; case 'T': case 'D': col = '3'; break; default: break; } } else if (qs[0] == 'O' && qs[1] == '=') { switch (qs[2]) { case 'A': ascending = '1'; break; case 'D': ascending = '0'; break; default: break; } } } while ((qs = strchr(qs, '&')) && *++qs); } buffer_append_string_len(b, CONST_STR_LEN("\n<script type=\"text/javascript\">\n// <!--\n\n")); buffer_append_string_len(b, js_simple_table_resort, sizeof(js_simple_table_resort)-1); buffer_append_string_len(b, js_simple_table_init_sort, sizeof(js_simple_table_init_sort)-1); buffer_append_string_len(b, CONST_STR_LEN("\ninit_sort(")); buffer_append_string_len(b, &col, 1); buffer_append_string_len(b, CONST_STR_LEN(", ")); buffer_append_string_len(b, &ascending, 1); buffer_append_string_len(b, CONST_STR_LEN(");\n\n// -->\n</script>\n\n")); }
static int mod_status_header_append_sort(buffer *b, void *p_d, const char* key) { plugin_data *p = p_d; if (p->conf.sort) { buffer_append_string_len(b, CONST_STR_LEN("<th class=\"status\"><a href=\"#\" class=\"sortheader\" onclick=\"resort(this);return false;\">")); buffer_append_string(b, key); buffer_append_string_len(b, CONST_STR_LEN("<span class=\"sortarrow\">:</span></a></th>\n")); } else { buffer_append_string_len(b, CONST_STR_LEN("<th class=\"status\">")); buffer_append_string(b, key); buffer_append_string_len(b, CONST_STR_LEN("</th>\n")); } return 0; }
void str2binstr(const char* instr, char** out) { buffer* b = buffer_init(); int last = strlen(instr); for (int i = 0; i < last; i++) { char tmp[8]="\0"; strncpy(tmp, instr + i, 1); int acsii_code = ((int)*tmp) & 0x000000ff; if (acsii_code < 128){ char* binStr; dec2Bin(acsii_code, &binStr); //Cdbg(1, "%s -> %d %d, binStr=%s", tmp, *tmp, acsii_code, binStr); buffer_append_string_len(b, binStr, 8); //Cdbg(1, "b=%s", b->ptr); free(binStr); } } //Cdbg(1, "11111111111111 %d %d %d", b->used, last*8, b->size+1); int len = last*8 + 1; *out = (char*)malloc(len); memset(*out, '\0', len); strcpy(*out, b->ptr); buffer_free(b); }
static int http_chunk_append_to_tempfile(server *srv, connection *con, const char * mem, size_t len) { chunkqueue * const cq = con->write_queue; if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) { /*http_chunk_append_len(srv, con, len);*/ buffer *b = srv->tmp_chunk_len; buffer_string_set_length(b, 0); buffer_append_uint_hex(b, len); buffer_append_string_len(b, CONST_STR_LEN("\r\n")); if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_BUF_LEN(b))) { return -1; } } if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, mem, len)) { return -1; } if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) { if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_STR_LEN("\r\n"))) { return -1; } } return 0; }
static int http_chunk_append_len(server *srv, connection *con, size_t len) { size_t i, olen = len, j; buffer *b; b = srv->tmp_chunk_len; if (len == 0) { buffer_copy_string_len(b, CONST_STR_LEN("0")); } else { for (i = 0; i < 8 && len; i++) { len >>= 4; } /* i is the number of hex digits we have */ buffer_prepare_copy(b, i + 1); for (j = i-1, len = olen; j+1 > 0; j--) { b->ptr[j] = (len & 0xf) + (((len & 0xf) <= 9) ? '0' : 'a' - 10); len >>= 4; } b->used = i; b->ptr[b->used++] = '\0'; } buffer_append_string_len(b, CONST_STR_LEN("\r\n")); chunkqueue_append_buffer(con->write_queue, b); return 0; }
static int build_doc_root(server *srv, connection *con, plugin_data *p, buffer *out, buffer *host) { stat_cache_entry *sce = NULL; buffer_prepare_copy(out, 128); if (p->conf.server_root->used) { buffer_copy_string_buffer(out, p->conf.server_root); if (host->used) { /* a hostname has to start with a alpha-numerical character * and must not contain a slash "/" */ char *dp; BUFFER_APPEND_SLASH(out); if (NULL == (dp = strchr(host->ptr, ':'))) { buffer_append_string_buffer(out, host); } else { buffer_append_string_len(out, host->ptr, dp - host->ptr); } } BUFFER_APPEND_SLASH(out); if (p->conf.document_root->used > 2 && p->conf.document_root->ptr[0] == '/') { buffer_append_string_len(out, p->conf.document_root->ptr + 1, p->conf.document_root->used - 2); } else { buffer_append_string_buffer(out, p->conf.document_root); BUFFER_APPEND_SLASH(out); } } else { buffer_copy_string_buffer(out, con->conf.document_root); BUFFER_APPEND_SLASH(out); } if (HANDLER_ERROR == stat_cache_get_entry(srv, con, out, &sce)) { if (p->conf.debug) { log_error_write(srv, __FILE__, __LINE__, "sb", strerror(errno), out); } return -1; } else if (!S_ISDIR(sce->st.st_mode)) { return -1; } return 0; }
static int data_response_insert_dup(data_unset *dst, data_unset *src) { data_string *ds_dst = (data_string *)dst; data_string *ds_src = (data_string *)src; if (!buffer_is_empty(ds_dst->value)) { buffer_append_string_len(ds_dst->value, CONST_STR_LEN("\r\n")); buffer_append_string_buffer(ds_dst->value, ds_dst->key); buffer_append_string_len(ds_dst->value, CONST_STR_LEN(": ")); buffer_append_string_buffer(ds_dst->value, ds_src->value); } else { buffer_copy_buffer(ds_dst->value, ds_src->value); } src->free(src); return 0; }
void buffer_append_int(buffer *b, intmax_t val) { char buf[LI_ITOSTRING_LENGTH]; char* const buf_end = buf + sizeof(buf); char *str; force_assert(NULL != b); str = itostr(buf_end, val); force_assert(buf_end > str && str >= buf); buffer_append_string_len(b, str, buf_end - str); }
static void http_list_directory_footer(server *srv, connection *con, plugin_data *p, buffer *out) { UNUSED(srv); buffer_append_string_len(out, CONST_STR_LEN( "</tbody>\n" "</table>\n" "</div>\n" )); if (p->conf.show_readme) { stream s; /* if we have a README file, display it in <pre class="readme"></pre> */ buffer_copy_string_buffer(p->tmp_buf, con->physical.path); BUFFER_APPEND_SLASH(p->tmp_buf); buffer_append_string_len(p->tmp_buf, CONST_STR_LEN("README.txt")); if (-1 != stream_open(&s, p->tmp_buf)) { if (p->conf.encode_readme) { buffer_append_string_len(out, CONST_STR_LEN("<pre class=\"readme\">")); buffer_append_string_encoded(out, s.start, s.size, ENCODING_MINIMAL_XML); buffer_append_string_len(out, CONST_STR_LEN("</pre>")); } else { buffer_append_string_len(out, s.start, s.size); } } stream_close(&s); } if(p->conf.auto_layout) { buffer_append_string_len(out, CONST_STR_LEN( "<div class=\"foot\">" )); if (p->conf.set_footer->used > 1) { buffer_append_string_buffer(out, p->conf.set_footer); } else if (buffer_is_empty(con->conf.server_tag)) { buffer_append_string_len(out, CONST_STR_LEN(PACKAGE_DESC)); } else { buffer_append_string_buffer(out, con->conf.server_tag); } buffer_append_string_len(out, CONST_STR_LEN( "</div>\n" "</body>\n" "</html>\n" )); } }
static void http_chunk_append_len(server *srv, connection *con, uintmax_t len) { buffer *b; force_assert(NULL != srv); b = srv->tmp_chunk_len; buffer_string_set_length(b, 0); buffer_append_uint_hex(b, len); buffer_append_string_len(b, CONST_STR_LEN("\r\n")); chunkqueue_append_buffer(con->write_queue, b); }
static void log_write(server *srv, buffer *b) { switch(srv->errorlog_mode) { case ERRORLOG_PIPE: case ERRORLOG_FILE: case ERRORLOG_FD: buffer_append_string_len(b, CONST_STR_LEN("\n")); write_all(srv->errorlog_fd, CONST_BUF_LEN(b)); break; case ERRORLOG_SYSLOG: syslog(LOG_ERR, "%s", b->ptr); break; } }
int config_append_cond_match_buffer(connection *con, data_config *dc, buffer *buf, int n) { cond_cache_t *cache = &con->cond_cache[dc->context_ndx]; if (n >= cache->patterncount) { return 0; } n <<= 1; /* n *= 2 */ buffer_append_string_len(buf, cache->comp_value->ptr + cache->matches[n], cache->matches[n + 1] - cache->matches[n]); return 1; }
//将src中的数据追加到b中 int buffer_append_string_buffer_len(buffer *b, const buffer *src, size_t len) { if (!src) { return -1; } if (src -> used == 0) { return 0; } return buffer_append_string_len(b, src -> ptr, len); }
static void http_list_directory_footer(server *srv, connection *con, plugin_data *p, buffer *out) { UNUSED(srv); buffer_append_string_len(out, CONST_STR_LEN( "</tbody>\n" "</table>\n" "</div>\n" )); if (p->conf.show_readme) { /* if we have a README file, display it in <pre class="readme"></pre> */ buffer_copy_buffer(p->tmp_buf, con->physical.path); buffer_append_slash(p->tmp_buf); buffer_append_string_len(p->tmp_buf, CONST_STR_LEN("README.txt")); http_list_directory_include_file(out, p->tmp_buf, "readme", p->conf.encode_readme); } if(p->conf.auto_layout) { buffer_append_string_len(out, CONST_STR_LEN( "<div class=\"foot\">" )); if (!buffer_string_is_empty(p->conf.set_footer)) { buffer_append_string_buffer(out, p->conf.set_footer); } else { buffer_append_string_buffer(out, con->conf.server_tag); } buffer_append_string_len(out, CONST_STR_LEN( "</div>\n" "</body>\n" "</html>\n" )); } }
static int data_string_insert_dup(data_unset *dst, data_unset *src) { data_string *ds_dst = (data_string *)dst; data_string *ds_src = (data_string *)src; if (ds_dst->value->used) { buffer_append_string_len(ds_dst->value, CONST_STR_LEN(", ")); buffer_append_string_buffer(ds_dst->value, ds_src->value); } else { buffer_copy_string_buffer(ds_dst->value, ds_src->value); } src->free(src); return 0; }
static int mod_status_row_append(buffer *b, const char *key, const char *value) { buffer_append_string_len(b, CONST_STR_LEN(" <tr>\n")); buffer_append_string_len(b, CONST_STR_LEN(" <td><b>")); buffer_append_string(b, key); buffer_append_string_len(b, CONST_STR_LEN("</b></td>\n")); buffer_append_string_len(b, CONST_STR_LEN(" <td>")); buffer_append_string(b, value); buffer_append_string_len(b, CONST_STR_LEN("</td>\n")); buffer_append_string_len(b, CONST_STR_LEN(" </tr>\n")); return 0; }
static void http_list_directory_footer(server *srv, connection *con, plugin_data *p, buffer *out) { UNUSED(srv); buffer_append_string_len(out, CONST_STR_LEN( "</tbody>\n" "</table>\n" "</div>\n" )); if (!buffer_string_is_empty(p->conf.show_readme)) { /* if we have a README file, display it in <pre class="readme"></pre> */ buffer *rb = p->conf.show_readme; if (rb->ptr[0] != '/') { buffer_copy_buffer(p->tmp_buf, con->physical.path); buffer_append_path_len(p->tmp_buf, CONST_BUF_LEN(p->conf.show_readme)); rb = p->tmp_buf; } http_list_directory_include_file(out, con->conf.follow_symlink, rb, "readme", p->conf.encode_readme); } if(p->conf.auto_layout) { buffer_append_string_len(out, CONST_STR_LEN( "<div class=\"foot\">" )); if (!buffer_string_is_empty(p->conf.set_footer)) { buffer_append_string_buffer(out, p->conf.set_footer); } else { buffer_append_string_buffer(out, con->conf.server_tag); } buffer_append_string_len(out, CONST_STR_LEN( "</div>\n" )); if (!buffer_string_is_empty(p->conf.external_js)) { buffer_append_string_len(out, CONST_STR_LEN("<script type=\"text/javascript\" src=\"")); buffer_append_string_buffer(out, p->conf.external_js); buffer_append_string_len(out, CONST_STR_LEN("\"></script>\n")); } else if (buffer_is_empty(p->conf.external_js)) { http_dirlist_append_js_table_resort(out, con); } buffer_append_string_len(out, CONST_STR_LEN( "</body>\n" "</html>\n" )); } }
int fcgi_demux_response(fastcgiResponse *fr) { int fin = 0; while (fin == 0) { fastcgi_response_packet packet; /* check if we have at least one packet */ if (0 != fastcgi_get_packet(fr, &packet)) { /* no full packet */ break; } switch(packet.type) { case FCGI_STDOUT: if (packet.len == 0) break; char *c; size_t blen; if (NULL != (c = buffer_search_string_len(packet.b, CONST_STR_LEN("\r\n\r\n")))) { blen = packet.b->used - (c - packet.b->ptr) - 4; //packet.b->used = (c - packet.b->ptr) + 3; c += 4; /* point the the start of the response */ } buffer_append_string_len(fr->format_buf, c, blen); //analyze format buffer get pubsub command break; case FCGI_STDERR: if (packet.len == 0) break; break; case FCGI_END_REQUEST: fin = 1; break; default: break; } buffer_free(packet.b); } return fin; }
int log_error_write_multiline_buffer(server *srv, const char *filename, unsigned int line, buffer *multiline, const char *fmt, ...) { va_list ap; size_t prefix_used; buffer *b = srv->errorlog_buf; char *pos, *end, *current_line; if (multiline->used < 2) return 0; if (-1 == log_buffer_prepare(b, srv, filename, line)) return 0; va_start(ap, fmt); log_buffer_append_printf(b, fmt, ap); va_end(ap); prefix_used = b->used; current_line = pos = multiline->ptr; end = multiline->ptr + multiline->used; for ( ; pos < end ; ++pos) { switch (*pos) { case '\n': case '\r': case '\0': /* handles end of string */ if (current_line < pos) { /* truncate to prefix */ b->used = prefix_used; b->ptr[b->used - 1] = '\0'; buffer_append_string_len(b, current_line, pos - current_line); log_write(srv, b); } current_line = pos + 1; break; default: break; } } return 0; }
void hexstr2binstr(const char* in_str, char** out_str) { char *tmp; buffer* ret = buffer_init(); for (tmp = in_str; *tmp; ++tmp){ int ten = hex2ten( (char*)(*tmp) ); char* binStr; ten2bin(ten, &binStr); //Cdbg(1, "444, binStr=%s", binStr); buffer_append_string_len(ret, binStr, 4); free(binStr); } *out_str = (char*)malloc(ret->size+1); strcpy(*out_str, ret->ptr); buffer_free(ret); }