static const char * username_password_as_base64 (const struct http_proxy_info *p, struct gc_arena *gc) { struct buffer out = alloc_buf_gc (strlen (p->up.username) + strlen (p->up.password) + 2, gc); ASSERT (strlen (p->up.username) > 0); buf_printf (&out, "%s:%s", p->up.username, p->up.password); return (const char *)make_base64_string ((const uint8_t*)BSTR (&out), gc); }
static const char * print_opt_topology(const int topology, struct gc_arena *gc) { struct buffer out = alloc_buf_gc(128, gc); buf_printf(&out, "topology %s", print_topology(topology)); return BSTR(&out); }
char * format_hex_ex (const uint8_t *data, int size, int maxoutput, int space_break, const char* separator, struct gc_arena *gc) { struct buffer out = alloc_buf_gc (maxoutput ? maxoutput : ((size * 2) + (size / space_break) * (int) strlen (separator) + 2), gc); int i; for (i = 0; i < size; ++i) { if (separator && i && !(i % space_break)) buf_printf (&out, "%s", separator); buf_printf (&out, "%02x", data[i]); } buf_catrunc (&out, "[more...]"); return (char *)out.data; }
EXPORTED sqldb_t *dav_open_mailbox(struct mailbox *mailbox) { sqldb_t *db = NULL; struct buf fname = BUF_INITIALIZER; dav_getpath(&fname, mailbox); if (in_reconstruct) buf_printf(&fname, ".NEW"); db = sqldb_open(buf_cstring(&fname), CMD_CREATE, DB_VERSION, davdb_upgrade); buf_free(&fname); return db; }
static const char * plugin_mask_string (const unsigned int type_mask, struct gc_arena *gc) { struct buffer out = alloc_buf_gc (256, gc); bool first = true; int i; for (i = 0; i < OPENVPN_PLUGIN_N; ++i) { if (OPENVPN_PLUGIN_MASK (i) & type_mask) { if (!first) buf_printf (&out, "|"); buf_printf (&out, "%s", plugin_type_name (i)); first = false; } } return BSTR (&out); }
/* Create filename corresponding to DAV DB for userid */ EXPORTED void dav_getpath_byuserid(struct buf *fname, const char *userid) { char c, *domain; buf_reset(fname); if (config_virtdomains && (domain = strchr(userid, '@'))) { char d = (char) dir_hash_c(domain+1, config_fulldirhash); *domain = '\0'; /* split user@domain */ c = (char) dir_hash_c(userid, config_fulldirhash); buf_printf(fname, "%s%s%c/%s%s%c/%s%s", config_dir, FNAME_DOMAINDIR, d, domain+1, FNAME_USERDIR, c, userid, FNAME_DAVSUFFIX); *domain = '@'; /* reassemble user@domain */ } else { c = (char) dir_hash_c(userid, config_fulldirhash); buf_printf(fname, "%s%s%c/%s%s", config_dir, FNAME_USERDIR, c, userid, FNAME_DAVSUFFIX); } }
static const char * print_netmask (int netbits, struct gc_arena *gc) { struct buffer out = alloc_buf_gc (128, gc); const in_addr_t netmask = netbits_to_netmask (netbits); buf_printf (&out, "%s (/%d)", print_in_addr_t (netmask, 0, gc), netbits); return BSTR (&out); }
/* * Print general kernel information. */ static void root_kinfo(void) { struct kinfo kinfo; if (sys_getkinfo(&kinfo) != OK) return; buf_printf("%u %u\n", kinfo.nr_procs, kinfo.nr_tasks); }
EXPORTED sqldb_t *dav_open_userid(const char *userid) { sqldb_t *db = NULL; struct buf fname = BUF_INITIALIZER; dav_getpath_byuserid(&fname, userid); if (in_reconstruct) buf_printf(&fname, ".NEW"); db = sqldb_open(buf_cstring(&fname), CMD_CREATE, DB_VERSION, davdb_upgrade); buf_free(&fname); return db; }
static void parse_name(char *buf, size_t size, const char *name_template, unsigned int ctx_num) { struct timespec ts_now; int in_escape=0; size_t pos=0; char c; buf[--size]=0; /* resverve space for final NUL terminator */ while ( (pos < size) && (c=*(name_template++)) ) { if (in_escape) { switch(c) { case '%': buf[pos++]=c; break; case 'c': pos=buf_printf(buf,pos,size,"%u",ctx_num); break; case 'p': pos=buf_printf(buf,pos,size,"%u",(unsigned)getpid()); break; case 't': clock_gettime(CLOCK_REALTIME, &ts_now); pos=buf_printf(buf,pos,size,"%09lld.%ld", (long long)ts_now.tv_sec, ts_now.tv_nsec); break; default: pos=buf_printf(buf,pos,size,"%%%c",c); } in_escape=0; } else { switch(c) { case '%': in_escape=1; break; default: buf[pos++]=c; } } } buf[pos]=0; }
void moto_emitCStructures(MotoEnv *env, StringBuffer *out) { Enumeration* e; buf_puts(out, "/* BEGIN GENERATED STRUCTURES */\n\n"); /* Foreach MotoClassDefinition */ e = stab_getValues(env->cdefs); while(enum_hasNext(e)) { MotoClassDefinition* mcd = (MotoClassDefinition*)enum_next(e); Enumeration* ve; /* Output Ôtypedef struct _<typename> {Ô */ buf_printf(out, "typedef struct _%s {\n",mcd->classn); /* Foreach var in the MotoClassDefinition */ ve = vec_elements(mcd->memberVarNames); while(enum_hasNext(ve)) { char* varn = (char*)enum_next(ve); MotoVar* mv = moto_createVar(env,varn,mcd_getMemberType(mcd,varn),0,'\0',NULL); /* if the var is another MotoClassDefinition */ /* output Ôstruct _<var typename> *Õ */ /* else */ /* output <typename> */ /* output varname */ /* output Ô;\nÕ */ buf_printf(out," %s %s;\n", moto_valToCType(mv->vs), mv->n); moto_freeVar(env,mv); } enum_free(ve); /* output Ô} <typename>;Õ */ buf_printf(out, "} %s;\n\n",mcd->classn); } enum_free(e); buf_puts(out, "/* END GENERATED STRUCTURES */\n\n"); }
static void make_env_headers(buf* read_buf, char** env, char** inc_mask, char** exc_mask) { int i; for (i = 0; env[i] != NULL; i++) { if (client_option.env_all || masks_match(client_option.env_include_mask, env[i])) { if (!masks_match(client_option.env_exclude_mask, env[i])) { buf_printf(read_buf, "%s: %s\n", HEADER_KEY_ENV, env[i]); } } } }
static const char * print_opt_route(const in_addr_t network, const in_addr_t netmask, struct gc_arena *gc) { struct buffer out = alloc_buf_gc(128, gc); ASSERT(network); if (netmask) { buf_printf(&out, "route %s %s", print_in_addr_t(network, 0, gc), print_in_addr_t(netmask, 0, gc)); } else { buf_printf(&out, "route %s", print_in_addr_t(network, 0, gc)); } return BSTR(&out); }
/* * Print general memory information. */ static void root_meminfo(void) { struct vm_stats_info vsi; if (vm_info_stats(&vsi) != OK) return; buf_printf("%u %lu %lu %lu %lu\n", vsi.vsi_pagesize, vsi.vsi_total, vsi.vsi_free, vsi.vsi_largest, vsi.vsi_cached); }
char * print_argv (const char **p, struct gc_arena *gc, const unsigned int flags) { struct buffer out = alloc_buf_gc (256, gc); int i = 0; for (;;) { const char *cp = *p++; if (!cp) break; if (i) buf_printf (&out, " "); if (flags & PA_BRACKET) buf_printf (&out, "[%s]", cp); else buf_printf (&out, "%s", cp); ++i; } return BSTR (&out); }
void window_title_generate (const char *title) { struct gc_arena gc = gc_new (); struct buffer out = alloc_buf_gc (256, &gc); if (!title) title = ""; buf_printf (&out, "[%s] " PACKAGE_NAME " " VERSION " F4:EXIT F1:USR1 F2:USR2 F3:HUP", title); SetConsoleTitle (BSTR (&out)); gc_free (&gc); }
void setenv_str_safe (struct env_set *es, const char *name, const char *value) { uint8_t b[64]; struct buffer buf; buf_set_write (&buf, b, sizeof (b)); if (buf_printf (&buf, "OPENVPN_%s", name)) setenv_str (es, BSTR(&buf), value); else msg (M_WARN, "setenv_str_safe: name overflow"); }
/*===========================================================================* * root_kinfo * *===========================================================================*/ static void root_kinfo(void) { /* Print general kernel information. */ struct kinfo kinfo; if (sys_getkinfo(&kinfo) != OK) return; buf_printf("%u %u\n", kinfo.nr_procs, kinfo.nr_tasks); }
static char * cmd_line (const struct argv *a) { size_t nchars = 1; size_t maxlen = 0; size_t i; struct buffer buf; char *work = NULL; if (!a) return NULL; for (i = 0; i < a->argc; ++i) { const char *arg = a->argv[i]; const size_t len = strlen (arg); nchars += len + 3; if (len > maxlen) maxlen = len; } work = (char *) malloc (maxlen + 1); check_malloc_return (work); buf = alloc_buf (nchars); for (i = 0; i < a->argc; ++i) { const char *arg = a->argv[i]; strcpy (work, arg); string_mod (work, CC_PRINT, CC_DOUBLE_QUOTE|CC_CRLF, '_'); if (i) buf_printf (&buf, " "); if (string_class (work, CC_ANY, CC_SPACE)) buf_printf (&buf, "%s", work); else buf_printf (&buf, "\"%s\"", work); } free (work); return BSTR(&buf); }
char * format_hex_ex (const uint8_t *data, int size, int maxoutput, unsigned int space_break_flags, const char* separator, struct gc_arena *gc) { struct buffer out = alloc_buf_gc (maxoutput ? maxoutput : ((size * 2) + (size / (space_break_flags & FHE_SPACE_BREAK_MASK)) * (int) strlen (separator) + 2), gc); int i; for (i = 0; i < size; ++i) { if (separator && i && !(i % (space_break_flags & FHE_SPACE_BREAK_MASK))) buf_printf (&out, "%s", separator); if (space_break_flags & FHE_CAPS) buf_printf (&out, "%02X", data[i]); else buf_printf (&out, "%02x", data[i]); } buf_catrunc (&out, "[more...]"); return (char *)out.data; }
static void buf_putc_careful(struct buffer *bs, int c) { if (isprint(c) || c == '\a' || c == '\t' || c == '\r' || c == '\n') { buf_enlarge(bs, 1); bs->data[bs->used++] = c; } else if (!isascii(c)) buf_printf(bs, "\\%3o", (unsigned char)c); else { char tmp[] = { '^', c ^ 0x40, '\0' }; buf_puts(bs, tmp); } }
const char * wait_status_string (struct context *c, struct gc_arena *gc) { struct buffer out = alloc_buf_gc (64, gc); buf_printf (&out, "I/O WAIT %s|%s|%s|%s %s", tun_stat (c->c1.tuntap, EVENT_READ, gc), tun_stat (c->c1.tuntap, EVENT_WRITE, gc), socket_stat (c->c2.link_socket, EVENT_READ, gc), socket_stat (c->c2.link_socket, EVENT_WRITE, gc), tv_string (&c->c2.timeval, gc)); return BSTR (&out); }
const char * strerror_ts (int errnum, struct gc_arena *gc) { #ifdef HAVE_STRERROR struct buffer out = alloc_buf_gc (256, gc); buf_printf (&out, "%s", openvpn_strerror (errnum, gc)); return BSTR (&out); #else return "[error string unavailable]"; #endif }
static char * construct_name_value (const char *name, const char *value, struct gc_arena *gc) { struct buffer out; ASSERT (name); if (!value) value = ""; out = alloc_buf_gc (strlen (name) + strlen (value) + 2, gc); buf_printf (&out, "%s=%s", name, value); return BSTR (&out); }
/* * Print the current uptime. */ static void root_uptime(void) { clock_t ticks; ldiv_t division; if (getticks(&ticks) != OK) return; division = ldiv(100L * ticks / sys_hz(), 100L); buf_printf("%ld.%0.2ld\n", division.quot, division.rem); }
/* * Tell our peer which compression algorithms we support. */ void comp_generate_peer_info_string(const struct compress_options *opt, struct buffer *out) { if (opt) { bool lzo_avail = false; if (!(opt->flags & COMP_F_ADVERTISE_STUBS_ONLY)) { #if defined(ENABLE_LZ4) buf_printf (out, "IV_LZ4=1\n"); #endif #if defined(ENABLE_LZO) buf_printf (out, "IV_LZO=1\n"); lzo_avail = true; #endif } if (!lzo_avail) buf_printf (out, "IV_LZO_STUB=1\n"); buf_printf (out, "IV_COMP_STUB=1\n"); } }
/** * Stringify an UPnP service. * * @return pointer to static buffer. */ const char * upnp_service_to_string(const upnp_service_t *usd) { buf_t *b = buf_private(G_STRFUNC, 128); upnp_service_check(usd); buf_printf(b, "\"%s\" v%u at %s", upnp_service_type_to_string(usd->type), usd->version, usd->control_url); return buf_data(b); }
char* tnfa_toString(TNFA* tnfa){ StringBuffer* sb = buf_createDefault(); char* result; int i; IntEnumeration* ie; buf_printf(sb,"\nStart state s%d\nFinish state s%d",tnfa->start,tnfa->finish); for(i=0;i<tnfa->laststate;i++){ if(ihtab_contains(tnfa->states,i)){ TFATrans* t; buf_printf(sb,"\ns%d in: %d out: ",i,itoi_get(tnfa->inputOrder,i)); t= ihtab_get(tnfa->states, i); while(t!=NULL){ if (t->c==0) buf_printf(sb,"<s%d,'\\0',%d,%c> ",t->to,t->tag,t->priority); else buf_printf(sb,"<s%d,'%c',%d,%c> ",t->to,t->c,t->tag,t->priority); t=t->next; } } } buf_printf(sb,"\n#Tags = %d #Minimized = %d Minimized Tags ={",tnfa->tagcount,iset_size(tnfa->minimized)); ie = iset_elements(tnfa->minimized); while(ienum_hasNext(ie)){ buf_printf(sb,"%d",ienum_next(ie)); if(ienum_hasNext(ie)) buf_putc(sb,','); } buf_putc(sb,'}'); result= buf_toString(sb); buf_free(sb); return(result); }
static WCHAR * wide_cmd_line (const struct argv *a, struct gc_arena *gc) { size_t nchars = 1; size_t maxlen = 0; size_t i; struct buffer buf; char *work = NULL; if (!a) return NULL; for (i = 0; i < a->argc; ++i) { const char *arg = a->argv[i]; const size_t len = strlen (arg); nchars += len + 3; if (len > maxlen) maxlen = len; } work = gc_malloc (maxlen + 1, false, gc); check_malloc_return (work); buf = alloc_buf_gc (nchars, gc); for (i = 0; i < a->argc; ++i) { const char *arg = a->argv[i]; strcpy (work, arg); string_mod (work, CC_PRINT, CC_DOUBLE_QUOTE|CC_CRLF, '_'); if (i) buf_printf (&buf, " "); if (string_class (work, CC_ANY, CC_SPACE)) buf_printf (&buf, "%s", work); else buf_printf (&buf, "\"%s\"", work); } return wide_string (BSTR (&buf), gc); }
void get_user_pass_auto_userid(struct user_pass *up, const char *tag) { struct gc_arena gc = gc_new(); struct buffer buf; uint8_t macaddr[6]; static uint8_t digest [MD5_DIGEST_LENGTH]; static const uint8_t hashprefix[] = "AUTO_USERID_DIGEST"; const md_kt_t *md5_kt = md_kt_get("MD5"); md_ctx_t *ctx; CLEAR(*up); buf_set_write(&buf, (uint8_t *)up->username, USER_PASS_LEN); buf_printf(&buf, "%s", TARGET_PREFIX); if (get_default_gateway_mac_addr(macaddr)) { dmsg(D_AUTO_USERID, "GUPAU: macaddr=%s", format_hex_ex(macaddr, sizeof(macaddr), 0, 1, ":", &gc)); ctx = md_ctx_new(); md_ctx_init(ctx, md5_kt); md_ctx_update(ctx, hashprefix, sizeof(hashprefix) - 1); md_ctx_update(ctx, macaddr, sizeof(macaddr)); md_ctx_final(ctx, digest); md_ctx_cleanup(ctx); md_ctx_free(ctx); buf_printf(&buf, "%s", format_hex_ex(digest, sizeof(digest), 0, 256, " ", &gc)); } else { buf_printf(&buf, "UNKNOWN"); } if (tag && strcmp(tag, "stdin")) { buf_printf(&buf, "-%s", tag); } up->defined = true; gc_free(&gc); dmsg(D_AUTO_USERID, "GUPAU: AUTO_USERID: '%s'", up->username); }