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);
}
