static int build_csv_record(char *buf, size_t bufsize, struct cw_cdr *cdr) { buf[0] = '\0'; /* Account code */ append_string(buf, cdr->accountcode, bufsize); /* Source */ append_string(buf, cdr->src, bufsize); /* Destination */ append_string(buf, cdr->dst, bufsize); /* Destination context */ append_string(buf, cdr->dcontext, bufsize); /* Caller*ID */ append_string(buf, cdr->clid, bufsize); /* Channel */ append_string(buf, cdr->channel, bufsize); /* Destination Channel */ append_string(buf, cdr->dstchannel, bufsize); /* Last Application */ append_string(buf, cdr->lastapp, bufsize); /* Last Data */ append_string(buf, cdr->lastdata, bufsize); /* Start Time */ append_date(buf, cdr->start, bufsize); /* Answer Time */ append_date(buf, cdr->answer, bufsize); /* End Time */ append_date(buf, cdr->end, bufsize); /* Duration */ append_int(buf, cdr->duration, bufsize); /* Billable seconds */ append_int(buf, cdr->billsec, bufsize); /* Disposition */ append_string(buf, cw_cdr_disp2str(cdr->disposition), bufsize); /* AMA Flags */ append_string(buf, cw_cdr_flags2str(cdr->amaflags), bufsize); #ifdef CSV_LOGUNIQUEID /* Unique ID */ append_string(buf, cdr->uniqueid, bufsize); #endif #ifdef CSV_LOGUSERFIELD /* append the user field */ append_string(buf, cdr->userfield,bufsize); #endif /* If we hit the end of our buffer, log an error */ if (strlen(buf) < bufsize - 5) { /* Trim off trailing comma */ buf[strlen(buf) - 1] = '\0'; strncat(buf, "\n", bufsize - strlen(buf) - 1); return 0; } return -1; }
int http_send_status_line(http_t *ctx, unsigned int code, const char *msg) { char buf[256], *p = buf; size_t size = sizeof buf; RUNTIME_ASSERT(code >= 100 && code <= 999); ACCLOG_SET(ctx->acclog, code, code); p = append_string(p, &size, "HTTP/1.1 "); p = append_uint(p, &size, code); p = append_char(p, &size, ' '); p = append_string(p, &size, msg); #if 0 DBUG("Sending HTTP response \"%s\"", buf); #endif p = APPEND_CRLF(p, &size); p = APPEND_STATIC_CHARS(p, &size, "Date: "); p = append_date(p, &size, compat_mono_time(NULL)); p = APPEND_CRLF(p, &size); if ( 0 != http_send(ctx, buf, sizeof buf - size) || 0 != http_send_str(ctx, http_server_header) ) return -1; return 0; }
struct mem_buf * template_get_chunk(struct template_chunk *chunk, const gwc_full_stats_t *stats) { char buf[1024], *p = buf; size_t avail = sizeof buf; switch (chunk->type) { case chunk_http_response: case chunk_http_header: case chunk_data: /* Must be handled elsewhere */ p = NULL; RUNTIME_ASSERT(0); break; case crab_stats_total_updates: p = append_uint64(buf, &avail, stats->total.updates); break; case crab_stats_total_updates_ip: p = append_uint64(buf, &avail, stats->total.ip_updates); break; case crab_stats_total_updates_url: p = append_uint64(buf, &avail, stats->total.url_updates); break; case crab_stats_total_requests: p = append_uint64(buf, &avail, stats->total.requests); break; case crab_stats_total_requests_base: p = append_uint64(buf, &avail, stats->total.base_requests); break; case crab_stats_total_requests_data: p = append_uint64(buf, &avail, stats->total.data_requests); break; case crab_stats_total_requests_get: p = append_uint64(buf, &avail, stats->total.get_requests); break; case crab_stats_total_requests_hostfile: p = append_uint64(buf, &avail, stats->total.hostfile_requests); break; case crab_stats_total_requests_urlfile: p = append_uint64(buf, &avail, stats->total.urlfile_requests); break; case crab_stats_total_requests_ping: p = append_uint64(buf, &avail, stats->total.ping_requests); break; case crab_stats_total_requests_statfile: p = append_uint64(buf, &avail, stats->total.statfile_requests); break; case crab_stats_total_accepts: p = append_uint64(buf, &avail, stats->total.accepts); break; case crab_stats_total_blocked: p = append_uint64(buf, &avail, stats->total.blocked); break; case crab_stats_total_errors: p = append_uint64(buf, &avail, stats->total.errors); break; case crab_stats_total_http_400s: p = append_uint64(buf, &avail, stats->total.http_400s); break; case crab_stats_total_http_404s: p = append_uint64(buf, &avail, stats->total.http_404s); break; case crab_stats_total_too_early: p = append_uint64(buf, &avail, stats->total.too_early); break; case crab_stats_total_rx: p = append_size(buf, &avail, stats->total.rx); break; case crab_stats_total_tx: p = append_size(buf, &avail, stats->total.tx); break; case crab_stats_hourly_updates: p = append_uint64(buf, &avail, stats->hourly.updates); break; case crab_stats_hourly_updates_ip: p = append_uint64(buf, &avail, stats->hourly.ip_updates); break; case crab_stats_hourly_updates_url: p = append_uint64(buf, &avail, stats->hourly.url_updates); break; case crab_stats_hourly_requests: p = append_uint64(buf, &avail, stats->hourly.requests); break; case crab_stats_hourly_requests_base: p = append_uint64(buf, &avail, stats->hourly.base_requests); break; case crab_stats_hourly_requests_data: p = append_uint64(buf, &avail, stats->hourly.data_requests); break; case crab_stats_hourly_requests_get: p = append_uint64(buf, &avail, stats->hourly.get_requests); break; case crab_stats_hourly_requests_hostfile: p = append_uint64(buf, &avail, stats->hourly.hostfile_requests); break; case crab_stats_hourly_requests_urlfile: p = append_uint64(buf, &avail, stats->hourly.urlfile_requests); break; case crab_stats_hourly_requests_ping: p = append_uint64(buf, &avail, stats->hourly.ping_requests); break; case crab_stats_hourly_requests_statfile: p = append_uint64(buf, &avail, stats->hourly.statfile_requests); break; case crab_stats_hourly_accepts: p = append_uint64(buf, &avail, stats->hourly.accepts); break; case crab_stats_hourly_blocked: p = append_uint64(buf, &avail, stats->hourly.blocked); break; case crab_stats_hourly_errors: p = append_uint64(buf, &avail, stats->hourly.errors); break; case crab_stats_hourly_http_400s: p = append_uint64(buf, &avail, stats->hourly.http_400s); break; case crab_stats_hourly_http_404s: p = append_uint64(buf, &avail, stats->hourly.http_404s); break; case crab_stats_hourly_too_early: p = append_uint64(buf, &avail, stats->hourly.too_early); break; case crab_stats_hourly_rx: p = append_size(buf, &avail, stats->hourly.rx); break; case crab_stats_hourly_tx: p = append_size(buf, &avail, stats->hourly.tx); break; case crab_startup_time: p = append_date(buf, &avail, stats->start_time.tv_sec); break; case crab_user_agent: p = append_string(buf, &avail, GWC_USER_AGENT); break; case crab_uri: p = append_string(buf, &avail, OPTION(gwc_uri)); break; case crab_url: p = append_string(buf, &avail, OPTION(gwc_url)); break; case crab_network_id: p = append_string(buf, &avail, OPTION(network_id) ? OPTION(network_id) : "gnutella"); break; case crab_contact_address: p = append_string(buf, &avail, OPTION(contact_address) ? OPTION(contact_address) : ""); break; #if defined(HAVE_GETRUSAGE) #define RU_TIME(x) stats->ru.x #else #define RU_TIME(x) 0 #endif /* HAVE_GETRUSAGE */ case crab_rusage_utime: { uint64_t v; v = (uint64_t) RU_TIME(ru_utime.tv_sec) * 1000000 + RU_TIME(ru_utime.tv_usec); p = append_uint64(buf, &avail, v); } break; case crab_rusage_stime: { uint64_t v; v = (uint64_t) RU_TIME(ru_stime.tv_sec) * 1000000 + RU_TIME(ru_stime.tv_usec); p = append_uint64(buf, &avail, v); } break; case crab_rusage_utime_percent: { uint64_t v; v = (uint64_t) RU_TIME(ru_utime.tv_sec) * 1000000 + RU_TIME(ru_utime.tv_usec); p = append_uint64(buf, &avail, v); } break; case crab_rusage_stime_percent: { uint64_t v; v = (uint64_t) RU_TIME(ru_stime.tv_sec) * 1000000 + RU_TIME(ru_stime.tv_usec); p = append_uint64(buf, &avail, v); } break; #if defined(HAVE_GETRUSAGE) && defined(HAVE_BSD_STRUCT_RUSAGE) #define RU(x) stats->ru.x #else #define RU(x) 0 #endif /* HAVE_GETRUSAGE && HAVE_BSD_STRUCT_RUSAGE */ case crab_rusage_maxrss: p = append_uint64(buf, &avail, RU(ru_maxrss)); break; case crab_rusage_ixrss: p = append_uint64(buf, &avail, RU(ru_ixrss)); break; case crab_rusage_idrss: p = append_uint64(buf, &avail, RU(ru_idrss)); break; case crab_rusage_isrss: p = append_uint64(buf, &avail, RU(ru_isrss)); break; case crab_rusage_minflt: p = append_uint64(buf, &avail, RU(ru_minflt)); break; case crab_rusage_majflt: p = append_uint64(buf, &avail, RU(ru_majflt)); break; case crab_rusage_nswap: p = append_uint64(buf, &avail, RU(ru_nswap)); break; case crab_rusage_inblock: p = append_uint64(buf, &avail, RU(ru_inblock)); break; case crab_rusage_oublock: p = append_uint64(buf, &avail, RU(ru_oublock)); break; case crab_rusage_msgsnd: p = append_uint64(buf, &avail, RU(ru_msgsnd)); break; case crab_rusage_msgrcv: p = append_uint64(buf, &avail, RU(ru_msgrcv)); break; case crab_rusage_nsignals: p = append_uint64(buf, &avail, RU(ru_nsignals)); break; case crab_rusage_nvcsw: p = append_uint64(buf, &avail, RU(ru_nvcsw)); break; case crab_rusage_nivcsw: p = append_uint64(buf, &avail, RU(ru_nivcsw)); break; #undef RU default: CRIT("Unknown chunk type (%u)", (unsigned) chunk->type); p = NULL; RUNTIME_ASSERT(0); } if (p && p != buf) { return mem_buf_new_copy(buf, p - buf); } return NULL; }
/* Checks the Date header of the message. RFC4474 [5] Step 3 */ static int date_proc(struct sip_msg* msg, char* srt1, char* str2) { str sdate; int iRes; time_t tmsg, tnow; if (glb_authservice_disabled) { LOG(L_WARN, "AUTH_IDENTITY:date_proc: Authentication Service is disabled\n"); return -1; } getstr_dynstr(&glb_sdate).len=0; /* we'd like to get the DATE header of the massage */ iRes=datehdr_proc(&sdate, NULL, msg); switch (iRes) { case AUTH_ERROR: return -1; case AUTH_NOTFOUND: if (append_date(&getstr_dynstr(&glb_sdate), glb_sdate.size, &tmsg, msg)) return -2; break; /* Message has Date header so we check that */ case AUTH_OK: #ifdef HAVE_TIMEGM tmsg=timegm(&get_date(msg)->date); #else tmsg=_timegm(&get_date(msg)->date); #endif if (tmsg < 0) { LOG(L_ERR, "AUTH_IDENTITY:date_proc: timegm error\n"); return -3; } if ((tnow=time(NULL))<0) { LOG(L_ERR, "AUTH_IDENTITY:date_proc: time error\n"); return -4; } /* * If the value of this field contains a time different by more than * ten minutes from the current time noted by the authentication * service then it should reject the message. */ if (tmsg + glb_imsgtime < tnow || tnow + glb_imsgtime < tmsg) { LOG(L_INFO, "AUTH_IDENTITY AUTHORIZER: Date header overdue\n"); return -6; } break; default: /* unknown result */ return -7; } /* * The authentication service MUST verify that the Date header * falls within the validity period of its certificate * RFC 4474 [6] Step 3 */ if (glb_imycertnotafter < tmsg) { LOG(L_INFO, "AUTH_IDENTITY AUTHORIZER: My certificate has been expired\n"); return -8; } return 1; }