/* Log a user supplied string. Escapes non-printable before
printing. */
void
_assuan_log_sanitized_string(const char *string)
{
const unsigned char *s = (const unsigned char *) string;
FILE *fp = assuan_get_assuan_log_stream();
if(! *s)
return;
#ifdef HAVE_FLOCKFILE
flockfile(fp);
#endif
for(; *s; s++)
{
int c = 0;
switch(*s)
{
case '\r':
c = 'r';
break;
case '\n':
c = 'n';
break;
case '\f':
c = 'f';
break;
case '\v':
c = 'v';
break;
case '\b':
c = 'b';
break;
default:
if((isascii(*s) && isprint(*s)) || (*s >= 0x80))
putc_unlocked(*s, fp);
else
{
putc_unlocked('\\', fp);
fprintf(fp, "x%02x", *s);
}
}
if(c)
{
putc_unlocked('\\', fp);
putc_unlocked(c, fp);
}
}
#ifdef HAVE_FUNLOCKFILE
funlockfile(fp);
#endif
}
/* Log a user supplied string. Escapes non-printable before
printing. */
void
_assuan_log_sanitized_string (const char *string)
{
const unsigned char *s = string;
FILE *fp = assuan_get_assuan_log_stream ();
if (! *s)
return;
for (; *s; s++)
{
int c = 0;
switch (*s)
{
case '\r':
c = 'r';
break;
case '\n':
c = 'n';
break;
case '\f':
c = 'f';
break;
case '\v':
c = 'v';
break;
case '\b':
c = 'b';
break;
default:
if ((isascii (*s) && isprint (*s)) || (*s >= 0x80))
putc (*s, fp);
else
{
putc ('\\', fp);
fprintf (fp, "x%02x", *s);
}
}
if (c)
{
putc ('\\', fp);
putc (c, fp);
}
}
}
void
_assuan_log_printf(const char *format, ...)
{
va_list arg_ptr;
FILE *fp;
const char *prf;
int save_errno = errno;
fp = assuan_get_assuan_log_stream();
prf = assuan_get_assuan_log_prefix();
if(*prf)
fprintf(fp, "%s[%u]: ", prf, (unsigned int)getpid());
va_start(arg_ptr, format);
vfprintf(fp, format, arg_ptr);
va_end(arg_ptr);
errno = save_errno;
}
void
_assuan_log_printf (const char *format, ...)
{
va_list arg_ptr;
FILE *fp;
const char *prf;
fp = assuan_get_assuan_log_stream ();
prf = assuan_get_assuan_log_prefix ();
if (*prf)
{
fputs (prf, fp);
fputs (": ", fp);
}
va_start (arg_ptr, format);
vfprintf (fp, format, arg_ptr );
va_end (arg_ptr);
}
void
_assuan_log_printf (const char *format, ...)
{
va_list arg_ptr;
FILE *fp;
const char *prf;
int save_errno = errno;
fp = assuan_get_assuan_log_stream ();
prf = assuan_get_assuan_log_prefix ();
if (*prf)
fprintf (fp, "%s[%u]: ", prf, (unsigned int)getpid ());
va_start (arg_ptr, format);
vfprintf (fp, format, arg_ptr );
va_end (arg_ptr);
/* If the log stream is a file, the output would be buffered. This
is bad for debugging, thus we flush the stream if FORMAT ends
with a LF. */
if (format && *format && format[strlen(format)-1] == '\n')
fflush (fp);
errno = save_errno;
}
/* Make a connection to the Unix domain socket NAME and return a new
Assuan context in CTX. SERVER_PID is currently not used but may
become handy in the future. With flags set to 1 sendmsg and
recvmesg are used. */
assuan_error_t
assuan_socket_connect_ext(assuan_context_t *r_ctx,
const char *name, pid_t server_pid,
unsigned int flags)
{
static struct assuan_io io = { _assuan_simple_read,
_assuan_simple_write
};
assuan_error_t err;
assuan_context_t ctx;
int fd;
struct sockaddr_un srvr_addr;
size_t len;
const char *s;
if(!r_ctx || !name)
return _assuan_error(ASSUAN_Invalid_Value);
*r_ctx = NULL;
/* We require that the name starts with a slash, so that we
eventually can reuse this function for other socket types. To
make things easier we allow an optional dirver prefix. */
s = name;
if(*s && s[1] == ':')
s += 2;
if(*s != DIRSEP_C && *s != '/')
return _assuan_error(ASSUAN_Invalid_Value);
if(strlen(name) + 1 >= sizeof srvr_addr.sun_path)
return _assuan_error(ASSUAN_Invalid_Value);
err = _assuan_new_context(&ctx);
if(err)
return err;
ctx->deinit_handler = ((flags & 1)) ? _assuan_uds_deinit : do_deinit;
ctx->finish_handler = do_finish;
fd = _assuan_sock_new(PF_LOCAL, SOCK_STREAM, 0);
if(fd == -1)
{
_assuan_log_printf("can't create socket: %s\n", strerror(errno));
_assuan_release_context(ctx);
return _assuan_error(ASSUAN_General_Error);
}
memset(&srvr_addr, 0, sizeof srvr_addr);
srvr_addr.sun_family = AF_LOCAL;
strncpy(srvr_addr.sun_path, name, sizeof(srvr_addr.sun_path) - 1);
srvr_addr.sun_path[sizeof(srvr_addr.sun_path) - 1] = 0;
len = SUN_LEN(&srvr_addr);
if(_assuan_sock_connect(fd, (struct sockaddr *) &srvr_addr, len) == -1)
{
_assuan_log_printf("can't connect to `%s': %s\n",
name, strerror(errno));
_assuan_release_context(ctx);
_assuan_close(fd);
return _assuan_error(ASSUAN_Connect_Failed);
}
ctx->inbound.fd = fd;
ctx->outbound.fd = fd;
ctx->io = &io;
if((flags & 1))
_assuan_init_uds_io(ctx);
/* initial handshake */
{
int okay, off;
err = _assuan_read_from_server(ctx, &okay, &off);
if(err)
_assuan_log_printf("can't connect to server: %s\n",
assuan_strerror(err));
else if(okay != 1)
{
/*LOG ("can't connect to server: `");*/
_assuan_log_sanitized_string(ctx->inbound.line);
fprintf(assuan_get_assuan_log_stream(), "'\n");
err = _assuan_error(ASSUAN_Connect_Failed);
}
}
if(err)
{
assuan_disconnect(ctx);
}
else
*r_ctx = ctx;
return 0;
}
