ims-volte-vowifi
/
strongswan
9
0
Fork 0
Code Pull Requests Releases Activity

Adding DBG_LIB to all calls of libstrongswan's version of DBG*.

This commit is contained in:
Tobias Brunner 2010-03-31 17:28:46 +02:00
parent 9ed6341d3f
commit 8b0e09103b
82 changed files with 660 additions and 576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/dumm/bridge.c
View File

@ -69,8 +69,8 @@ static bool disconnect_iface(private_bridge_t *this, iface_t *iface)
{
if (br_del_interface(this->name, iface->get_hostif(iface)) != 0)
{
DBG1("removing iface '%s' from bridge '%s' in kernel failed: %m",
iface->get_hostif(iface), this->name);
DBG1(DBG_LIB, "removing iface '%s' from bridge '%s' in kernel"
" failed: %m", iface->get_hostif(iface), this->name);
}
else
{
@ -83,8 +83,8 @@ static bool disconnect_iface(private_bridge_t *this, iface_t *iface)
}
if (iface != current)
{
DBG1("iface '%s' not found on bridge '%s'", iface->get_hostif(iface),
this->name);
DBG1(DBG_LIB, "iface '%s' not found on bridge '%s'",
iface->get_hostif(iface), this->name);
}
enumerator->destroy(enumerator);
return good;
@ -97,7 +97,7 @@ static bool connect_iface(private_bridge_t *this, iface_t *iface)
{
if (br_add_interface(this->name, iface->get_hostif(iface)) != 0)
{
DBG1("adding iface '%s' to bridge '%s' failed: %m",
DBG1(DBG_LIB, "adding iface '%s' to bridge '%s' failed: %m",
iface->get_hostif(iface), this->name);
return FALSE;
}
@ -124,7 +124,8 @@ static void destroy(private_bridge_t *this)
{
if (br_del_interface(this->name, iface->get_hostif(iface)) != 0)
{
DBG1("disconnecting iface '%s' failed: %m", iface->get_hostif(iface));
DBG1(DBG_LIB, "disconnecting iface '%s' failed: %m",
iface->get_hostif(iface));
}
iface->set_bridge(iface, NULL);
}
@ -133,7 +134,8 @@ static void destroy(private_bridge_t *this)
iface_control(this->name, FALSE);
if (br_del_bridge(this->name) != 0)
{
DBG1("deleting bridge '%s' from kernel failed: %m", this->name);
DBG1(DBG_LIB, "deleting bridge '%s' from kernel failed: %m",
this->name);
}
free(this->name);
free(this);
@ -154,7 +156,7 @@ bridge_t *bridge_create(char *name)
{
if (br_init() != 0)
{
DBG1("libbridge initialization failed: %m");
DBG1(DBG_LIB, "libbridge initialization failed: %m");
return NULL;
}
}
@ -168,13 +170,13 @@ bridge_t *bridge_create(char *name)
if (br_add_bridge(name) != 0)
{
DBG1("creating bridge '%s' failed: %m", name);
DBG1(DBG_LIB, "creating bridge '%s' failed: %m", name);
free(this);
return NULL;
}
if (!iface_control(name, TRUE))
{
DBG1("bringing bridge '%s' up failed: %m", name);
DBG1(DBG_LIB, "bringing bridge '%s' up failed: %m", name);
}
this->name = strdup(name);

16
src/dumm/cowfs.c
View File

@ -493,12 +493,12 @@ static int cowfs_link(const char *from, const char *to)
if (!clone_path(rd, wr, to))
{
DBG1("cloning path '%s' failed", to);
DBG1(DBG_LIB, "cloning path '%s' failed", to);
return -errno;
}
if (linkat(rd, from, wr, to, 0) < 0)
{
DBG1("linking '%s' to '%s' failed", from, to);
DBG1(DBG_LIB, "linking '%s' to '%s' failed", from, to);
return -errno;
}
return 0;
@ -777,7 +777,7 @@ static bool set_overlay(private_cowfs_t *this, char *path)
this->over_fd = open(path, O_RDONLY | O_DIRECTORY);
if (this->over_fd < 0)
{
DBG1("failed to open overlay directory '%s': %m", path);
DBG1(DBG_LIB, "failed to open overlay directory '%s': %m", path);
return FALSE;
}
this->over = strdup(path);
@ -821,14 +821,14 @@ cowfs_t *cowfs_create(char *master, char *host, char *mount)
this->master_fd = open(master, O_RDONLY | O_DIRECTORY);
if (this->master_fd < 0)
{
DBG1("failed to open master filesystem '%s'", master);
DBG1(DBG_LIB, "failed to open master filesystem '%s'", master);
free(this);
return NULL;
}
this->host_fd = open(host, O_RDONLY | O_DIRECTORY);
if (this->host_fd < 0)
{
DBG1("failed to open host filesystem '%s'", host);
DBG1(DBG_LIB, "failed to open host filesystem '%s'", host);
close(this->master_fd);
free(this);
return NULL;
@ -838,7 +838,7 @@ cowfs_t *cowfs_create(char *master, char *host, char *mount)
this->chan = fuse_mount(mount, &args);
if (this->chan == NULL)
{
DBG1("mounting cowfs FUSE on '%s' failed", mount);
DBG1(DBG_LIB, "mounting cowfs FUSE on '%s' failed", mount);
close(this->master_fd);
close(this->host_fd);
free(this);
@ -849,7 +849,7 @@ cowfs_t *cowfs_create(char *master, char *host, char *mount)
sizeof(cowfs_operations), this);
if (this->fuse == NULL)
{
DBG1("creating cowfs FUSE handle failed");
DBG1(DBG_LIB, "creating cowfs FUSE handle failed");
close(this->master_fd);
close(this->host_fd);
fuse_unmount(mount, this->chan);
@ -865,7 +865,7 @@ cowfs_t *cowfs_create(char *master, char *host, char *mount)
this->thread = thread_create((thread_main_t)fuse_loop, this->fuse);
if (!this->thread)
{
DBG1("creating thread to handle FUSE failed");
DBG1(DBG_LIB, "creating thread to handle FUSE failed");
fuse_unmount(mount, this->chan);
free(this->mount);
free(this->master);

11
src/dumm/dumm.c
View File

@ -162,7 +162,7 @@ static bool load_template(private_dumm_t *this, char *dir)
}
if (strlen(dir) > PATH_MAX)
{
DBG1("template directory string '%s' is too long", dir);
DBG1(DBG_LIB, "template directory string '%s' is too long", dir);
return FALSE;
}
@ -175,7 +175,8 @@ static bool load_template(private_dumm_t *this, char *dir)
{ /* does not exist, create template */
if (!mkdir_p(this->template, PERME))
{
DBG1("creating template directory '%s' failed: %m", this->template);
DBG1(DBG_LIB, "creating template directory '%s' failed: %m",
this->template);
return FALSE;
}
}
@ -302,7 +303,8 @@ static void load_guests(private_dumm_t *this)
}
else
{
DBG1("loading guest in directory '%s' failed, skipped", ent->d_name);
DBG1(DBG_LIB, "loading guest in directory '%s' failed, skipped",
ent->d_name);
}
}
closedir(dir);
@ -360,7 +362,8 @@ dumm_t *dumm_create(char *dir)
if (this->dir == NULL || this->guest_dir == NULL ||
(mkdir(this->guest_dir, PERME) < 0 && errno != EEXIST))
{
DBG1("creating guest directory '%s' failed: %m", this->guest_dir);
DBG1(DBG_LIB, "creating guest directory '%s' failed: %m",
this->guest_dir);
destroy(this);
return NULL;
}

20
src/dumm/guest.c
View File

@ -100,7 +100,8 @@ static iface_t* create_iface(private_guest_t *this, char *name)
if (this->state != GUEST_RUNNING)
{
DBG1("guest '%s' not running, unable to add interface", this->name);
DBG1(DBG_LIB, "guest '%s' not running, unable to add interface",
this->name);
return NULL;
}
@ -109,7 +110,8 @@ static iface_t* create_iface(private_guest_t *this, char *name)
{
if (streq(name, iface->get_guestif(iface)))
{
DBG1("guest '%s' already has an interface '%s'", this->name, name);
DBG1(DBG_LIB, "guest '%s' already has an interface '%s'",
this->name, name);
enumerator->destroy(enumerator);
return NULL;
}
@ -251,7 +253,8 @@ static bool start(private_guest_t *this, invoke_function_t invoke, void* data,
if (this->state != GUEST_STOPPED)
{
DBG1("unable to start guest in state %N", guest_state_names, this->state);
DBG1(DBG_LIB, "unable to start guest in state %N", guest_state_names,
this->state);
return FALSE;
}
this->state = GUEST_STARTING;
@ -284,7 +287,7 @@ static bool start(private_guest_t *this, invoke_function_t invoke, void* data,
this->mconsole = mconsole_create(notify, idle);
if (this->mconsole == NULL)
{
DBG1("opening mconsole at '%s' failed, stopping guest", buf);
DBG1(DBG_LIB, "opening mconsole at '%s' failed, stopping guest", buf);
stop(this, NULL);
return FALSE;
}
@ -315,7 +318,8 @@ static bool load_template(private_guest_t *this, char *path)
{
if (!mkdir_p(dir, PERME))
{
DBG1("creating overlay for guest '%s' failed: %m", this->name);
DBG1(DBG_LIB, "creating overlay for guest '%s' failed: %m",
this->name);
return FALSE;
}
}
@ -595,7 +599,7 @@ static private_guest_t *guest_create_generic(char *parent, char *name,
this->dir = open(this->dirname, O_DIRECTORY, PERME);
if (this->dir < 0)
{
DBG1("opening guest directory '%s' failed: %m", this->dirname);
DBG1(DBG_LIB, "opening guest directory '%s' failed: %m", this->dirname);
free(this->dirname);
free(this);
return NULL;
@ -647,7 +651,7 @@ guest_t *guest_create(char *parent, char *name, char *kernel,
if (!make_symlink(this, master, MASTER_DIR) ||
!make_symlink(this, kernel, KERNEL_FILE))
{
DBG1("creating master/kernel symlink failed: %m");
DBG1(DBG_LIB, "creating master/kernel symlink failed: %m");
destroy(this);
return NULL;
}
@ -655,7 +659,7 @@ guest_t *guest_create(char *parent, char *name, char *kernel,
if (mkdirat(this->dir, UNION_DIR, PERME) != 0 ||
mkdirat(this->dir, DIFF_DIR, PERME) != 0)
{
DBG1("unable to create directories for '%s': %m", name);
DBG1(DBG_LIB, "unable to create directories for '%s': %m", name);
destroy(this);
return NULL;
}

14
src/dumm/iface.c
View File

@ -196,7 +196,7 @@ static bool destroy_tap(private_iface_t *this)
if (!iface_control(this->hostif, FALSE))
{
DBG1("bringing iface down failed: %m");
DBG1(DBG_LIB, "bringing iface down failed: %m");
}
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
@ -205,13 +205,13 @@ static bool destroy_tap(private_iface_t *this)
tap = open(TAP_DEVICE, O_RDWR);
if (tap < 0)
{
DBG1("unable to open tap device %s: %m", TAP_DEVICE);
DBG1(DBG_LIB, "unable to open tap device %s: %m", TAP_DEVICE);
return FALSE;
}
if (ioctl(tap, TUNSETIFF, &ifr) < 0 ||
ioctl(tap, TUNSETPERSIST, 0) < 0)
{
DBG1("removing %s failed: %m", this->hostif);
DBG1(DBG_LIB, "removing %s failed: %m", this->hostif);
close(tap);
return FALSE;
}
@ -235,14 +235,14 @@ static char* create_tap(private_iface_t *this)
tap = open(TAP_DEVICE, O_RDWR);
if (tap < 0)
{
DBG1("unable to open tap device %s: %m", TAP_DEVICE);
DBG1(DBG_LIB, "unable to open tap device %s: %m", TAP_DEVICE);
return NULL;
}
if (ioctl(tap, TUNSETIFF, &ifr) < 0 ||
ioctl(tap, TUNSETPERSIST, 1) < 0 ||
ioctl(tap, TUNSETOWNER, 0))
{
DBG1("creating new tap device failed: %m");
DBG1(DBG_LIB, "creating new tap device failed: %m");
close(tap);
return NULL;
}
@ -299,7 +299,7 @@ iface_t *iface_create(char *name, guest_t *guest, mconsole_t *mconsole)
}
if (!this->mconsole->add_iface(this->mconsole, this->guestif, this->hostif))
{
DBG1("creating interface '%s' in guest failed", this->guestif);
DBG1(DBG_LIB, "creating interface '%s' in guest failed", this->guestif);
destroy_tap(this);
free(this->guestif);
free(this->hostif);
@ -308,7 +308,7 @@ iface_t *iface_create(char *name, guest_t *guest, mconsole_t *mconsole)
}
if (!iface_control(this->hostif, TRUE))
{
DBG1("bringing iface '%s' up failed: %m", this->hostif);
DBG1(DBG_LIB, "bringing iface '%s' up failed: %m", this->hostif);
}
return &this->public;
}

22
src/dumm/mconsole.c
View File

@ -120,7 +120,7 @@ static int request(private_mconsole_t *this, void(*cb)(void*,char*,size_t),
if (len < 0)
{
DBG1("sending mconsole command to UML failed: %m");
DBG1(DBG_LIB, "sending mconsole command to UML failed: %m");
return -1;
}
do
@ -136,7 +136,7 @@ static int request(private_mconsole_t *this, void(*cb)(void*,char*,size_t),
}
if (len < 0)
{
DBG1("receiving from mconsole failed: %m");
DBG1(DBG_LIB, "receiving from mconsole failed: %m");
return -1;
}
if (len > 0)
@ -149,7 +149,7 @@ static int request(private_mconsole_t *this, void(*cb)(void*,char*,size_t),
{
if (reply.len && *reply.data)
{
DBG1("received mconsole error %d: %.*s",
DBG1(DBG_LIB, "received mconsole error %d: %.*s",
reply.err, reply.len, reply.data);
}
break;
@ -245,7 +245,7 @@ static bool wait_for_notify(private_mconsole_t *this, char *nsock)
this->notify = socket(AF_UNIX, SOCK_DGRAM, 0);
if (this->notify < 0)
{
DBG1("opening mconsole notify socket failed: %m");
DBG1(DBG_LIB, "opening mconsole notify socket failed: %m");
return FALSE;
}
memset(&addr, 0, sizeof(addr));
@ -253,7 +253,8 @@ static bool wait_for_notify(private_mconsole_t *this, char *nsock)
strncpy(addr.sun_path, nsock, sizeof(addr.sun_path));
if (bind(this->notify, (struct sockaddr*)&addr, sizeof(addr)) < 0)
{
DBG1("binding mconsole notify socket to '%s' failed: %m", nsock);
DBG1(DBG_LIB, "binding mconsole notify socket to '%s' failed: %m",
nsock);
close(this->notify);
return FALSE;
}
@ -273,7 +274,7 @@ static bool wait_for_notify(private_mconsole_t *this, char *nsock)
if (len < 0 || len >= sizeof(notify))
{
DBG1("reading from mconsole notify socket failed: %m");
DBG1(DBG_LIB, "reading from mconsole notify socket failed: %m");
close(this->notify);
unlink(nsock);
return FALSE;
@ -282,8 +283,8 @@ static bool wait_for_notify(private_mconsole_t *this, char *nsock)
notify.version != MCONSOLE_VERSION ||
notify.type != MCONSOLE_SOCKET)
{
DBG1("received unexpected message from mconsole notify socket: %b",
&notify, sizeof(notify));
DBG1(DBG_LIB, "received unexpected message from mconsole notify"
" socket: %b", &notify, sizeof(notify));
close(this->notify);
unlink(nsock);
return FALSE;
@ -304,7 +305,7 @@ static bool setup_console(private_mconsole_t *this)
this->console = socket(AF_UNIX, SOCK_DGRAM, 0);
if (this->console < 0)
{
DBG1("opening mconsole socket failed: %m");
DBG1(DBG_LIB, "opening mconsole socket failed: %m");
return FALSE;
}
memset(&addr, 0, sizeof(addr));
@ -313,7 +314,8 @@ static bool setup_console(private_mconsole_t *this)
getpid(), this->console);
if (bind(this->console, (struct sockaddr*)&addr, sizeof(addr)) < 0)
{
DBG1("binding mconsole socket to '%s' failed: %m", &addr.sun_path[1]);
DBG1(DBG_LIB, "binding mconsole socket to '%s' failed: %m",
&addr.sun_path[1]);
close(this->console);
return FALSE;
}

17
src/libfast/smtp.c
View File

@ -83,7 +83,7 @@ static int write_cmd(private_smtp_t *this, char *fmt, ...)
if (fprintf(this->f, "%s\n", buf) < 1)
{
DBG1("sending SMTP command failed");
DBG1(DBG_LIB, "sending SMTP command failed");
return 0;
}
return read_response(this);
@ -96,17 +96,17 @@ METHOD(smtp_t, send_mail, bool,
if (write_cmd(this, "MAIL FROM:<%s>", from) != 250)
{
DBG1("SMTP MAIL FROM failed");
DBG1(DBG_LIB, "SMTP MAIL FROM failed");
return FALSE;
}
if (write_cmd(this, "RCPT TO:<%s>", to) != 250)
{
DBG1("SMTP RCPT TO failed");
DBG1(DBG_LIB, "SMTP RCPT TO failed");
return FALSE;
}
if (write_cmd(this, "DATA") != 354)
{
DBG1("SMTP DATA failed");
DBG1(DBG_LIB, "SMTP DATA failed");
return FALSE;
}
@ -149,7 +149,7 @@ smtp_t *smtp_create()
s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 0)
{
DBG1("opening SMTP socket failed: %s", strerror(errno));
DBG1(DBG_LIB, "opening SMTP socket failed: %s", strerror(errno));
free(this);
return NULL;
}
@ -158,7 +158,7 @@ smtp_t *smtp_create()
addr.sin_port = htons(25);
if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) < 0)
{
DBG1("connecting to SMTP server failed: %s", strerror(errno));
DBG1(DBG_LIB, "connecting to SMTP server failed: %s", strerror(errno));
close(s);
free(this);
return NULL;
@ -166,7 +166,8 @@ smtp_t *smtp_create()
this->f = fdopen(s, "a+");
if (!this->f)
{
DBG1("opening stream to SMTP server failed: %s", strerror(errno));
DBG1(DBG_LIB, "opening stream to SMTP server failed: %s",
strerror(errno));
close(s);
free(this);
return NULL;
@ -174,7 +175,7 @@ smtp_t *smtp_create()
if (read_response(this) != 220 ||
write_cmd(this, "EHLO localhost") != 250)
{
DBG1("SMTP EHLO failed");
DBG1(DBG_LIB, "SMTP EHLO failed");
fclose(this->f);
free(this);
return NULL;

6
src/libhydra/attributes/attribute_manager.c
View File

@ -83,7 +83,7 @@ static host_t* acquire_address(private_attribute_manager_t *this,
if (!host)
{
DBG1("acquiring address from pool '%s' failed", pool);
DBG1(DBG_LIB, "acquiring address from pool '%s' failed", pool);
}
return host;
}
@ -113,7 +113,7 @@ static void release_address(private_attribute_manager_t *this,
if (!found)
{
DBG1("releasing address to pool '%s' failed", pool);
DBG1(DBG_LIB, "releasing address to pool '%s' failed", pool);
}
}
@ -206,7 +206,7 @@ static attribute_handler_t* handle(private_attribute_manager_t *this,
if (!handled)
{
DBG1("handling %N attribute failed",
DBG1(DBG_LIB, "handling %N attribute failed",
configuration_attribute_type_names, type);
}
return handled;

19
src/libhydra/attributes/mem_pool.c
View File

@ -203,7 +203,7 @@ METHOD(mem_pool_t, acquire_address, host_t*,
requested->get_family(requested) !=
this->base->get_family(this->base))
{
DBG1("IP pool address family mismatch");
DBG1(DBG_LIB, "IP pool address family mismatch");
return NULL;
}
@ -217,7 +217,7 @@ METHOD(mem_pool_t, acquire_address, host_t*,
id = this->ids->get(this->ids, id);
if (id)
{
DBG1("reassigning offline lease to '%Y'", id);
DBG1(DBG_LIB, "reassigning offline lease to '%Y'", id);
this->online->put(this->online, id, (void*)offset);
break;
}
@ -227,7 +227,7 @@ METHOD(mem_pool_t, acquire_address, host_t*,
offset = (uintptr_t)this->online->get(this->online, id);
if (offset && offset == host2offset(this, requested))
{
DBG1("reassigning online lease to '%Y'", id);
DBG1(DBG_LIB, "reassigning online lease to '%Y'", id);
break;
}
@ -239,7 +239,7 @@ METHOD(mem_pool_t, acquire_address, host_t*,
id = id->clone(id);
this->ids->put(this->ids, id, id);
this->online->put(this->online, id, (void*)offset);
DBG1("assigning new lease to '%Y'", id);
DBG1(DBG_LIB, "assigning new lease to '%Y'", id);
break;
}
@ -252,8 +252,8 @@ METHOD(mem_pool_t, acquire_address, host_t*,
{
/* destroy reference to old ID */
old_id = this->ids->remove(this->ids, old_id);
DBG1("reassigning existing offline lease by '%Y' to '%Y'",
old_id, id);
DBG1(DBG_LIB, "reassigning existing offline lease by '%Y'"
" to '%Y'", old_id, id);
if (old_id)
{
old_id->destroy(old_id);
@ -267,7 +267,8 @@ METHOD(mem_pool_t, acquire_address, host_t*,
}
enumerator->destroy(enumerator);
DBG1("pool '%s' is full, unable to assign address", this->name);
DBG1(DBG_LIB, "pool '%s' is full, unable to assign address",
this->name);
break;
}
this->lock->unlock(this->lock);
@ -293,7 +294,7 @@ METHOD(mem_pool_t, release_address, bool,
id = this->ids->get(this->ids, id);
if (id)
{
DBG1("lease %H by '%Y' went offline", address, id);
DBG1(DBG_LIB, "lease %H by '%Y' went offline", address, id);
this->offline->put(this->offline, id, (void*)offset);
found = TRUE;
}
@ -432,7 +433,7 @@ mem_pool_t *mem_pool_create(char *name, host_t *base, int bits)
if (bits > POOL_LIMIT)
{
bits = POOL_LIMIT;
DBG1("virtual IP pool too large, limiting to %H/%d",
DBG1(DBG_LIB, "virtual IP pool too large, limiting to %H/%d",
base, addr_bits - bits);
}
this->size = 1 << (bits);

2
src/libhydra/hydra.c
View File

@ -65,7 +65,7 @@ bool libhydra_init(const char *daemon)
if (lib->integrity &&
!lib->integrity->check(lib->integrity, "libhydra", libhydra_init))
{
DBG1("integrity check of libhydra failed");
DBG1(DBG_LIB, "integrity check of libhydra failed");
return FALSE;
}
return TRUE;

4
src/libhydra/plugins/attr/attr_provider.c
View File

@ -174,7 +174,7 @@ static void load_entries(private_attr_provider_t *this)
host = host_create_from_string(token, 0);
if (!host)
{
DBG1("invalid host in key %s: %s", key, token);
DBG1(DBG_LIB, "invalid host in key %s: %s", key, token);
continue;
}
if (!type)
@ -195,7 +195,7 @@ static void load_entries(private_attr_provider_t *this)
}
if (!type)
{
DBG1("mapping attribute type %s failed", key);
DBG1(DBG_LIB, "mapping attribute type %s failed", key);
break;
}
}

4
src/libhydra/plugins/attr_sql/attr_sql_plugin.c
View File

@ -65,7 +65,7 @@ plugin_t *attr_sql_plugin_create()
uri = lib->settings->get_str(lib->settings, "libhydra.plugins.attr-sql.database", NULL);
if (!uri)
{
DBG1("attr-sql plugin: database URI not set");
DBG1(DBG_LIB, "attr-sql plugin: database URI not set");
return NULL;
}
@ -76,7 +76,7 @@ plugin_t *attr_sql_plugin_create()
this->db = lib->db->create(lib->db, uri);
if (!this->db)
{
DBG1("attr-sql plugin failed to connect to database");
DBG1(DBG_LIB, "attr-sql plugin failed to connect to database");
free(this);
return NULL;
}

8
src/libhydra/plugins/attr_sql/sql_attribute.c
View File

@ -127,8 +127,8 @@ static host_t* check_lease(private_sql_attribute_t *this, char *name,
host = host_create_from_chunk(AF_UNSPEC, address, 0);
if (host)
{
DBG1("acquired existing lease for address %H in pool '%s'",
host, name);
DBG1(DBG_LIB, "acquired existing lease for address %H in"
" pool '%s'", host, name);
return host;
}
}
@ -202,13 +202,13 @@ static host_t* get_lease(private_sql_attribute_t *this, char *name,
host = host_create_from_chunk(AF_UNSPEC, address, 0);
if (host)
{
DBG1("acquired new lease for address %H in pool '%s'",
DBG1(DBG_LIB, "acquired new lease for address %H in pool '%s'",
host, name);
return host;
}
}
}
DBG1("no available address found in pool '%s'", name);
DBG1(DBG_LIB, "no available address found in pool '%s'", name);
return NULL;
}

35
src/libstrongswan/asn1/asn1.c
View File

@ -133,7 +133,7 @@ size_t asn1_length(chunk_t *blob)
if (blob->len < 2)
{
DBG2("insufficient number of octets to parse ASN.1 length");
DBG2(DBG_LIB, "insufficient number of octets to parse ASN.1 length");
return ASN1_INVALID_LENGTH;
}
@ -145,7 +145,7 @@ size_t asn1_length(chunk_t *blob)
{ /* single length octet */
if (n > blob->len)
{
DBG2("length is larger than remaining blob size");
DBG2(DBG_LIB, "length is larger than remaining blob size");
return ASN1_INVALID_LENGTH;
}
return n;
@ -156,14 +156,14 @@ size_t asn1_length(chunk_t *blob)
if (n == 0 || n > blob->len)
{
DBG2("number of length octets invalid");
DBG2(DBG_LIB, "number of length octets invalid");
return ASN1_INVALID_LENGTH;
}
if (n > sizeof(len))
{
DBG2("number of length octets is larger than limit of %d octets",
(int)sizeof(len));
DBG2(DBG_LIB, "number of length octets is larger than limit of"
" %d octets", (int)sizeof(len));
return ASN1_INVALID_LENGTH;
}
@ -176,7 +176,7 @@ size_t asn1_length(chunk_t *blob)
}
if (len > blob->len)
{
DBG2("length is larger than remaining blob size");
DBG2(DBG_LIB, "length is larger than remaining blob size");
return ASN1_INVALID_LENGTH;
}
return len;
@ -376,7 +376,7 @@ void asn1_debug_simple_object(chunk_t object, asn1_t type, bool private)
oid = asn1_known_oid(object);
if (oid != OID_UNKNOWN)
{
DBG2(" '%s'", oid_names[oid].name);
DBG2(DBG_LIB, " '%s'", oid_names[oid].name);
return;
}
break;
@ -385,14 +385,14 @@ void asn1_debug_simple_object(chunk_t object, asn1_t type, bool private)
case ASN1_PRINTABLESTRING:
case ASN1_T61STRING:
case ASN1_VISIBLESTRING:
DBG2(" '%.*s'", (int)object.len, object.ptr);
DBG2(DBG_LIB, " '%.*s'", (int)object.len, object.ptr);
return;
case ASN1_UTCTIME:
case ASN1_GENERALIZEDTIME:
{
time_t time = asn1_to_time(&object, type);
DBG2(" '%T'", &time, TRUE);
DBG2(DBG_LIB, " '%T'", &time, TRUE);
}
return;
default:
@ -400,11 +400,11 @@ void asn1_debug_simple_object(chunk_t object, asn1_t type, bool private)
}
if (private)
{
DBG4("%B", &object);
DBG4(DBG_LIB, "%B", &object);
}
else
{
DBG3("%B", &object);
DBG3(DBG_LIB, "%B", &object);
}
}
@ -418,13 +418,14 @@ bool asn1_parse_simple_object(chunk_t *object, asn1_t type, u_int level, const c
/* an ASN.1 object must possess at least a tag and length field */
if (object->len < 2)
{
DBG2("L%d - %s: ASN.1 object smaller than 2 octets", level, name);
DBG2(DBG_LIB, "L%d - %s: ASN.1 object smaller than 2 octets", level,
name);
return FALSE;
}
if (*object->ptr != type)
{
DBG2("L%d - %s: ASN1 tag 0x%02x expected, but is 0x%02x",
DBG2(DBG_LIB, "L%d - %s: ASN1 tag 0x%02x expected, but is 0x%02x",
level, name, type, *object->ptr);
return FALSE;
}
@ -433,12 +434,12 @@ bool asn1_parse_simple_object(chunk_t *object, asn1_t type, u_int level, const c
if (len == ASN1_INVALID_LENGTH || object->len < len)
{
DBG2("L%d - %s: length of ASN.1 object invalid or too large",
DBG2(DBG_LIB, "L%d - %s: length of ASN.1 object invalid or too large",
level, name);
return FALSE;
}
DBG2("L%d - %s:", level, name);
DBG2(DBG_LIB, "L%d - %s:", level, name);
asn1_debug_simple_object(*object, type, FALSE);
return TRUE;
}
@ -500,7 +501,7 @@ bool is_asn1(chunk_t blob)
if (tag != ASN1_SEQUENCE && tag != ASN1_SET && tag != ASN1_OCTET_STRING)
{
DBG2(" file content is not binary ASN.1");
DBG2(DBG_LIB, " file content is not binary ASN.1");
return FALSE;
}
@ -518,7 +519,7 @@ bool is_asn1(chunk_t blob)
return TRUE;
}
DBG2(" file size does not match ASN.1 coded length");
DBG2(DBG_LIB, " file size does not match ASN.1 coded length");
return FALSE;
}

18
src/libstrongswan/asn1/asn1_parser.c
View File

@ -122,7 +122,7 @@ static bool iterate(private_asn1_parser_t *this, int *objectID, chunk_t *object)
if ((obj.flags & ASN1_DEF) && (blob->len == 0 || *start_ptr != obj.type) )
{
/* field is missing */
DBG2("L%d - %s:", level, obj.name);
DBG2(DBG_LIB, "L%d - %s:", level, obj.name);
if (obj.type & ASN1_CONSTRUCTED)
{
this->line++ ; /* skip context-specific tag */
@ -149,7 +149,7 @@ static bool iterate(private_asn1_parser_t *this, int *objectID, chunk_t *object)
if (blob->len < 2)
{
DBG1("L%d - %s: ASN.1 object smaller than 2 octets",
DBG1(DBG_LIB, "L%d - %s: ASN.1 object smaller than 2 octets",
level, obj.name);
this->success = FALSE;
goto end;
@ -159,7 +159,7 @@ static bool iterate(private_asn1_parser_t *this, int *objectID, chunk_t *object)
if (blob1->len == ASN1_INVALID_LENGTH)
{
DBG1("L%d - %s: length of ASN.1 object invalid or too large",
DBG1(DBG_LIB, "L%d - %s: length of ASN.1 object invalid or too large",
level, obj.name);
this->success = FALSE;
}
@ -172,7 +172,7 @@ static bool iterate(private_asn1_parser_t *this, int *objectID, chunk_t *object)
if (obj.flags & ASN1_RAW)
{
DBG2("L%d - %s:", level, obj.name);
DBG2(DBG_LIB, "L%d - %s:", level, obj.name);
object->ptr = start_ptr;
object->len = (size_t)(blob->ptr - start_ptr);
goto end;
@ -180,14 +180,14 @@ static bool iterate(private_asn1_parser_t *this, int *objectID, chunk_t *object)
if (*start_ptr != obj.type && !(this->implicit && this->line == 0))
{
DBG1("L%d - %s: ASN1 tag 0x%02x expected, but is 0x%02x",
DBG1(DBG_LIB, "L%d - %s: ASN1 tag 0x%02x expected, but is 0x%02x",
level, obj.name, obj.type, *start_ptr);
DBG3("%b", start_ptr, (u_int)(blob->ptr - start_ptr));
DBG3(DBG_LIB, "%b", start_ptr, (u_int)(blob->ptr - start_ptr));
this->success = FALSE;
goto end;
}
DBG2("L%d - %s:", level, obj.name);
DBG2(DBG_LIB, "L%d - %s:", level, obj.name);
/* In case of "SEQUENCE OF" or "SET OF" start a loop */
if (obj.flags & ASN1_LOOP)
@ -216,11 +216,11 @@ static bool iterate(private_asn1_parser_t *this, int *objectID, chunk_t *object)
object->len = (size_t)(blob->ptr - start_ptr);
if (this->private)
{
DBG4("%B", object);
DBG4(DBG_LIB, "%B", object);
}
else
{
DBG3("%B", object);
DBG3(DBG_LIB, "%B", object);
}
}
else if (obj.flags & ASN1_BODY)

11
src/libstrongswan/chunk.c
View File

@ -221,7 +221,7 @@ bool chunk_write(chunk_t chunk, char *path, char *label, mode_t mask, bool force
if (!force && access(path, F_OK) == 0)
{
DBG1(" %s file '%s' already exists", label, path);
DBG1(DBG_LIB, " %s file '%s' already exists", label, path);
return FALSE;
}
oldmask = umask(mask);
@ -230,20 +230,21 @@ bool chunk_write(chunk_t chunk, char *path, char *label, mode_t mask, bool force
{
if (fwrite(chunk.ptr, sizeof(u_char), chunk.len, fd) == chunk.len)
{
DBG1(" written %s file '%s' (%d bytes)",
DBG1(DBG_LIB, " written %s file '%s' (%d bytes)",
label, path, chunk.len);
good = TRUE;
}
else
{
DBG1(" writing %s file '%s' failed: %s",
DBG1(DBG_LIB, " writing %s file '%s' failed: %s",
label, path, strerror(errno));
}
fclose(fd);
}
else
{
DBG1(" could not open %s file '%s': %s", label, path, strerror(errno));
DBG1(DBG_LIB, " could not open %s file '%s': %s", label, path,
strerror(errno));
}
umask(oldmask);
return good;
@ -496,7 +497,7 @@ bool chunk_printable(chunk_t chunk, chunk_t *sane, char replace)
* Described in header.
*
* The implementation is based on Paul Hsieh's SuperFastHash:
* http://www.azillionmonkeys.com/qed/hash.html
* http://www.azillionmonkeys.com/qed/hash.html
*/
u_int32_t chunk_hash_inc(chunk_t chunk, u_int32_t hash)
{

2
src/libstrongswan/credentials/credential_factory.c
View File

@ -151,7 +151,7 @@ static void* create(private_credential_factory_t *this, credential_type_t type,
{
names = certificate_type_names;
}
DBG1("building %N - %N failed, tried %d builders",
DBG1(DBG_LIB, "building %N - %N failed, tried %d builders",
credential_type_names, type, names, subtype, failures);
}
this->recursive->set(this->recursive, (void*)level);

2
src/libstrongswan/crypto/crypto_factory.c
View File

@ -686,7 +686,7 @@ static void add_test_vector(private_crypto_factory_t *this,
case RANDOM_NUMBER_GENERATOR:
return this->tester->add_rng_vector(this->tester, vector);
default:
DBG1("%N test vectors not supported, ignored",
DBG1(DBG_LIB, "%N test vectors not supported, ignored",
transform_type_names, type);
}
}

40
src/libstrongswan/crypto/crypto_tester.c
View File

@ -136,7 +136,7 @@ static bool test_crypter(private_crypto_tester_t *this,
crypter->destroy(crypter);
if (failed)
{
DBG1("disabled %N: test vector %u failed",
DBG1(DBG_LIB, "disabled %N: test vector %u failed",
encryption_algorithm_names, alg, tested);
break;
}
@ -144,14 +144,14 @@ static bool test_crypter(private_crypto_tester_t *this,
enumerator->destroy(enumerator);
if (!tested)
{
DBG1("%s %N: no test vectors found",
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
encryption_algorithm_names, alg);
return !this->required;
}
if (!failed)
{
DBG1("enabled %N: passed %u test vectors",
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
encryption_algorithm_names, alg, tested);
}
return !failed;
@ -183,7 +183,7 @@ static bool test_signer(private_crypto_tester_t *this,
signer = create(alg);
if (!signer)
{
DBG1("disabled %N: creating instance failed",
DBG1(DBG_LIB, "disabled %N: creating instance failed",
integrity_algorithm_names, alg);
failed = TRUE;
break;
@ -240,7 +240,7 @@ static bool test_signer(private_crypto_tester_t *this,
signer->destroy(signer);
if (failed)
{
DBG1("disabled %N: test vector %u failed",
DBG1(DBG_LIB, "disabled %N: test vector %u failed",
integrity_algorithm_names, alg, tested);
break;
}
@ -248,14 +248,14 @@ static bool test_signer(private_crypto_tester_t *this,
enumerator->destroy(enumerator);
if (!tested)
{
DBG1("%s %N: no test vectors found",
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
integrity_algorithm_names, alg);
return !this->required;
}
if (!failed)
{
DBG1("enabled %N: passed %u test vectors",
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
integrity_algorithm_names, alg, tested);
}
return !failed;
@ -287,7 +287,7 @@ static bool test_hasher(private_crypto_tester_t *this, hash_algorithm_t alg,
hasher = create(alg);
if (!hasher)
{
DBG1("disabled %N: creating instance failed",
DBG1(DBG_LIB, "disabled %N: creating instance failed",
hash_algorithm_names, alg);
failed = TRUE;
break;
@ -330,7 +330,7 @@ static bool test_hasher(private_crypto_tester_t *this, hash_algorithm_t alg,
hasher->destroy(hasher);
if (failed)
{
DBG1("disabled %N: test vector %u failed",
DBG1(DBG_LIB, "disabled %N: test vector %u failed",
hash_algorithm_names, alg, tested);
break;
}
@ -338,14 +338,14 @@ static bool test_hasher(private_crypto_tester_t *this, hash_algorithm_t alg,
enumerator->destroy(enumerator);
if (!tested)
{
DBG1("%s %N: no test vectors found",
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
hash_algorithm_names, alg);
return !this->required;
}
if (!failed)
{
DBG1("enabled %N: passed %u test vectors",
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
hash_algorithm_names, alg, tested);
}
return !failed;
@ -377,7 +377,7 @@ static bool test_prf(private_crypto_tester_t *this,
prf = create(alg);
if (!prf)
{
DBG1("disabled %N: creating instance failed",
DBG1(DBG_LIB, "disabled %N: creating instance failed",
pseudo_random_function_names, alg);
failed = TRUE;
break;
@ -431,7 +431,7 @@ static bool test_prf(private_crypto_tester_t *this,
prf->destroy(prf);
if (failed)
{
DBG1("disabled %N: test vector %u failed",
DBG1(DBG_LIB, "disabled %N: test vector %u failed",
pseudo_random_function_names, alg, tested);
break;
}
@ -439,14 +439,14 @@ static bool test_prf(private_crypto_tester_t *this,
enumerator->destroy(enumerator);
if (!tested)
{
DBG1("%s %N: no test vectors found",
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? "disabled" : "enabled ",
pseudo_random_function_names, alg);
return !this->required;
}
if (!failed)
{
DBG1("enabled %N: passed %u test vectors",
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
pseudo_random_function_names, alg, tested);
}
return !failed;
@ -465,7 +465,7 @@ static bool test_rng(private_crypto_tester_t *this, rng_quality_t quality,
if (!this->rng_true && quality == RNG_TRUE)
{
DBG1("enabled %N: skipping test (disabled by config)",
DBG1(DBG_LIB, "enabled %N: skipping test (disabled by config)",
rng_quality_names, quality);
return TRUE;
}
@ -485,7 +485,7 @@ static bool test_rng(private_crypto_tester_t *this, rng_quality_t quality,
rng = create(quality);
if (!rng)
{
DBG1("disabled %N: creating instance failed",
DBG1(DBG_LIB, "disabled %N: creating instance failed",
rng_quality_names, quality);
failed = TRUE;
break;
@ -515,7 +515,7 @@ static bool test_rng(private_crypto_tester_t *this, rng_quality_t quality,
rng->destroy(rng);
if (failed)
{
DBG1("disabled %N: test vector %u failed",
DBG1(DBG_LIB, "disabled %N: test vector %u failed",
rng_quality_names, quality, tested);
break;
}
@ -523,14 +523,14 @@ static bool test_rng(private_crypto_tester_t *this, rng_quality_t quality,
enumerator->destroy(enumerator);
if (!tested)
{
DBG1("%s %N: no test vectors found",
DBG1(DBG_LIB, "%s %N: no test vectors found",
this->required ? ", disabled" : "enabled ",
rng_quality_names, quality);
return !this->required;
}
if (!failed)
{
DBG1("enabled %N: passed %u test vectors",
DBG1(DBG_LIB, "enabled %N: passed %u test vectors",
rng_quality_names, quality, tested);
}
return !failed;

82
src/libstrongswan/crypto/pkcs7.c
View File

@ -152,13 +152,13 @@ static bool abort_parsing(private_pkcs7_t *this, int type)
{
if (this->type != type)
{
DBG1("pkcs7 content to be parsed is not of type '%s'",
DBG1(DBG_LIB, "pkcs7 content to be parsed is not of type '%s'",
oid_names[type]);
return TRUE;
}
if (this->parsed)
{
DBG1("pkcs7 content has already been parsed");
DBG1(DBG_LIB, "pkcs7 content has already been parsed");
return TRUE;
}
this->parsed = TRUE;
@ -301,14 +301,14 @@ static bool parse_signedData(private_pkcs7_t *this, x509_t *cacert)
}
case PKCS7_SIGNER_INFO:
signerInfos++;
DBG2(" signer #%d", signerInfos);
DBG2(DBG_LIB, " signer #%d", signerInfos);
break;
case PKCS7_SIGNED_ISSUER:
{
identification_t *issuer;
issuer = identification_create_from_encoding(ID_DER_ASN1_DN, object);
DBG2(" '%Y'", issuer);
DBG2(DBG_LIB, " '%Y'", issuer);
issuer->destroy(issuer);
break;
}
@ -344,33 +344,33 @@ end:
if (signerInfos == 0)
{
DBG1("no signerInfo object found");
DBG1(DBG_LIB, "no signerInfo object found");
return FALSE;
}
else if (signerInfos > 1)
{
DBG1("more than one signerInfo object found");
DBG1(DBG_LIB, "more than one signerInfo object found");
return FALSE;
}
if (this->attributes == NULL)
{
DBG1("no authenticatedAttributes object found");
DBG1(DBG_LIB, "no authenticatedAttributes object found");
return FALSE;
}
if (enc_alg != OID_RSA_ENCRYPTION)
{
DBG1("only RSA digest encryption supported");
DBG1(DBG_LIB, "only RSA digest encryption supported");
return FALSE;
}
if (signer->verify_emsa_pkcs1_signature(signer, algorithm,
this->attributes->get_encoding(this->attributes), encrypted_digest) != SUCCESS)
{
DBG1("invalid digest signature");
DBG1(DBG_LIB, "invalid digest signature");
return FALSE;
}
else
{
DBG2("digest signature is valid");
DBG2(DBG_LIB, "digest signature is valid");
}
if (this->data.ptr != NULL)
{
@ -378,7 +378,7 @@ end:
if (messageDigest.ptr == NULL)
{
DBG1("messageDigest attribute not found");
DBG1(DBG_LIB, "messageDigest attribute not found");
return FALSE;
}
else
@ -390,25 +390,25 @@ end:
hasher = lib->crypto->create_hasher(lib->crypto, algorithm)
if (hasher == NULL)
{
DBG1("hash algorithm %N not supported",
DBG1(DBG_LIB, "hash algorithm %N not supported",
hash_algorithm_names, algorithm);
free(messageDigest.ptr);
return FALSE;
}
hasher->allocate_hash(hasher, this->data, &hash);
hasher->destroy(hasher);
DBG3("hash: %B", &hash);
DBG3(DBG_LIB, "hash: %B", &hash);
valid = chunk_equals(messageDigest, hash);
free(messageDigest.ptr);
free(hash.ptr);
if (valid)
{
DBG2("messageDigest is valid");
DBG2(DBG_LIB, "messageDigest is valid");
}
else
{
DBG1("invalid messageDigest");
DBG1(DBG_LIB, "invalid messageDigest");
return FALSE;
}
}
@ -480,14 +480,14 @@ static bool parse_envelopedData(private_pkcs7_t *this, chunk_t serialNumber,
case PKCS7_ENVELOPED_VERSION:
if (*object.ptr != 0)
{
DBG1("envelopedData version is not 0");
DBG1(DBG_LIB, "envelopedData version is not 0");
goto end;
}
break;
case PKCS7_RECIPIENT_INFO_VERSION:
if (*object.ptr != 0)
{
DBG1("recipient info version is not 0");
DBG1(DBG_LIB, "recipient info version is not 0");
goto end;
}
break;
@ -496,14 +496,14 @@ static bool parse_envelopedData(private_pkcs7_t *this, chunk_t serialNumber,
identification_t *issuer;
issuer = identification_create_from_encoding(ID_DER_ASN1_DN, object);
DBG2(" '%Y'", issuer);
DBG2(DBG_LIB, " '%Y'", issuer);
issuer->destroy(issuer);
}
break;
case PKCS7_SERIAL_NUMBER:
if (!chunk_equals(serialNumber, object))
{
DBG1("serial numbers do not match");
DBG1(DBG_LIB, "serial numbers do not match");
goto end;
}
break;
@ -513,7 +513,7 @@ static bool parse_envelopedData(private_pkcs7_t *this, chunk_t serialNumber,
if (alg != OID_RSA_ENCRYPTION)
{
DBG1("only rsa encryption supported");
DBG1(DBG_LIB, "only rsa encryption supported");
goto end;
}
}
@ -521,15 +521,15 @@ static bool parse_envelopedData(private_pkcs7_t *this, chunk_t serialNumber,
case PKCS7_ENCRYPTED_KEY:
if (key->pkcs1_decrypt(key, object, &symmetric_key) != SUCCESS)
{
DBG1("symmetric key could not be decrypted with rsa");
DBG1(DBG_LIB, "symmetric key could not be decrypted with rsa");
goto end;
}
DBG4("symmetric key : %B", &symmetric_key);
DBG4(DBG_LIB, "symmetric key : %B", &symmetric_key);
break;
case PKCS7_CONTENT_TYPE:
if (known_oid(object) != OID_PKCS7_DATA)
{
DBG1("encrypted content not of type pkcs7 data");
DBG1(DBG_LIB, "encrypted content not of type pkcs7 data");
goto end;
}
break;
@ -546,22 +546,22 @@ static bool parse_envelopedData(private_pkcs7_t *this, chunk_t serialNumber,
crypter = crypter_create(ENCR_3DES, 0);
break;
default:
DBG1("Only DES and 3DES supported for symmetric encryption");
DBG1(DBG_LIB, "Only DES and 3DES supported for symmetric encryption");
goto end;
}
if (symmetric_key.len != crypter->get_key_size(crypter))
{
DBG1("symmetric key has wrong length");
DBG1(DBG_LIB, "symmetric key has wrong length");
goto end;
}
if (!parse_asn1_simple_object(&iv, ASN1_OCTET_STRING, level+1, "IV"))
{
DBG1("IV could not be parsed");
DBG1(DBG_LIB, "IV could not be parsed");
goto end;
}
if (iv.len != crypter->get_block_size(crypter))
{
DBG1("IV has wrong length");
DBG1(DBG_LIB, "IV has wrong length");
goto end;
}
}
@ -583,7 +583,7 @@ end:
/* decrypt the content */
crypter->set_key(crypter, symmetric_key);
crypter->decrypt(crypter, encrypted_content, iv, &this->data);
DBG3("decrypted content with padding: %B", &this->data);
DBG3(DBG_LIB, "decrypted content with padding: %B", &this->data);
/* remove the padding */
{
@ -593,7 +593,7 @@ end:
if (padding > this->data.len)
{
DBG1("padding greater than data length");
DBG1(DBG_LIB, "padding greater than data length");
goto failed;
}
this->data.len -= padding;
@ -602,7 +602,7 @@ end:
{
if (*pos-- != pattern)
{
DBG1("wrong padding pattern");
DBG1(DBG_LIB, "wrong padding pattern");
goto failed;
}
}
@ -656,7 +656,7 @@ static chunk_t get_contentInfo(private_pkcs7_t *this)
break;
case OID_UNKNOWN:
default:
DBG1("invalid pkcs7 contentInfo type");
DBG1(DBG_LIB, "invalid pkcs7 contentInfo type");
return chunk_empty;
}
@ -727,7 +727,7 @@ bool build_envelopedData(private_pkcs7_t *this, x509_t *cert,
alg_oid = ASN1_3des_ede_cbc_oid;
break;
default:
DBG1(" encryption algorithm %N not supported",
DBG1(DBG_LIB, " encryption algorithm %N not supported",
encryption_algorithm_names, alg);
return FALSE;
}
@ -735,7 +735,7 @@ bool build_envelopedData(private_pkcs7_t *this, x509_t *cert,
crypter = crypter_create(alg, 0);
if (crypter == NULL)
{
DBG1(" could not create crypter for algorithm %N",
DBG1(DBG_LIB, " could not create crypter for algorithm %N",
encryption_algorithm_names, alg);
return FALSE;
}
@ -748,12 +748,12 @@ bool build_envelopedData(private_pkcs7_t *this, x509_t *cert,
rng = lib->crypto->create_rng(lib->crypto, RNG_TRUE);
rng->allocate_bytes(rng, crypter->get_key_size(crypter), &symmetricKey);
DBG4(" symmetric encryption key: %B", &symmetricKey);
DBG4(DBG_LIB, " symmetric encryption key: %B", &symmetricKey);
rng->destroy(rng);
rng = lib->crypto->create_rng(lib->crypto, RNG_WEAK);
rng->allocate_bytes(rng, crypter->get_block_size(crypter), &iv);
DBG4(" initialization vector: %B", &iv);
DBG4(DBG_LIB, " initialization vector: %B", &iv);
rng->destroy(rng);
}
@ -767,7 +767,7 @@ bool build_envelopedData(private_pkcs7_t *this, x509_t *cert,
in.len = this->data.len + padding;
in.ptr = malloc(in.len);
DBG2(" padding %d bytes of data to multiple block size of %d bytes",
DBG2(DBG_LIB, " padding %d bytes of data to multiple block size of %d bytes",
(int)this->data.len, (int)in.len);
/* copy data */
@ -775,14 +775,14 @@ bool build_envelopedData(private_pkcs7_t *this, x509_t *cert,
/* append padding */
memset(in.ptr + this->data.len, padding, padding);
}
DBG3(" padded unencrypted data: %B", &in);
DBG3(DBG_LIB, " padded unencrypted data: %B", &in);
/* symmetric encryption of data object */
crypter->set_key(crypter, symmetricKey);
crypter->encrypt(crypter, in, iv, &out);
crypter->destroy(crypter);
chunk_clear(&in);
DBG3(" encrypted data: %B", &out);
DBG3(DBG_LIB, " encrypted data: %B", &out);
/* build pkcs7 enveloped data object */
{
@ -834,7 +834,7 @@ bool build_signedData(private_pkcs7_t *this, rsa_private_key_t *private_key,
if (this->certs->get_first(this->certs, (void**)&cert) != SUCCESS)
{
DBG1(" no pkcs7 signer certificate found");
DBG1(DBG_LIB, " no pkcs7 signer certificate found");
return FALSE;
}
@ -847,7 +847,7 @@ bool build_signedData(private_pkcs7_t *this, rsa_private_key_t *private_key,
hasher = lib->crypto->create_hasher(lib->crypto, alg);
if (hasher == NULL)
{
DBG1(" hash algorithm %N not support",
DBG1(DBG_LIB, " hash algorithm %N not support",
hash_algorithm_names, alg);
return FALSE;
}
@ -963,7 +963,7 @@ static bool parse_contentInfo(chunk_t blob, u_int level0, private_pkcs7_t *cInfo
if (cInfo->type < OID_PKCS7_DATA
|| cInfo->type > OID_PKCS7_ENCRYPTED_DATA)
{
DBG1("unknown pkcs7 content type");
DBG1(DBG_LIB, "unknown pkcs7 content type");
goto end;
}
}

2
src/libstrongswan/fetcher/fetcher_manager.c
View File

@ -134,7 +134,7 @@ static status_t fetch(private_fetcher_manager_t *this,
this->lock->unlock(this->lock);
if (!capable)
{
DBG1("unable to fetch from %s, no capable fetcher found", url);
DBG1(DBG_LIB, "unable to fetch from %s, no capable fetcher found", url);
}
return status;
}

37
src/libstrongswan/integrity_checker.c
View File

@ -72,13 +72,14 @@ static u_int32_t build_file(private_integrity_checker_t *this, char *file,
fd = open(file, O_RDONLY);
if (fd == -1)
{
DBG1(" opening '%s' failed: %s", file, strerror(errno));
DBG1(DBG_LIB, " opening '%s' failed: %s", file, strerror(errno));
return 0;
}
if (fstat(fd, &sb) == -1)
{
DBG1(" getting file size of '%s' failed: %s", file, strerror(errno));
DBG1(DBG_LIB, " getting file size of '%s' failed: %s", file,
strerror(errno));
close(fd);
return 0;
}
@ -86,7 +87,7 @@ static u_int32_t build_file(private_integrity_checker_t *this, char *file,
addr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (addr == MAP_FAILED)
{
DBG1(" mapping '%s' failed: %s", file, strerror(errno));
DBG1(DBG_LIB, " mapping '%s' failed: %s", file, strerror(errno));
close(fd);
return 0;
}
@ -146,13 +147,13 @@ static u_int32_t build_segment(private_integrity_checker_t *this, void *sym,
if (dladdr(sym, &dli) == 0)
{
DBG1(" unable to locate symbol: %s", dlerror());
DBG1(DBG_LIB, " unable to locate symbol: %s", dlerror());
return 0;
}
/* we reuse the Dl_info struct as in/out parameter */
if (!dl_iterate_phdr((void*)callback, &dli))
{
DBG1(" executable section not found");
DBG1(DBG_LIB, " executable section not found");
return 0;
}
@ -192,7 +193,7 @@ static bool check_file(private_integrity_checker_t *this,
cs = find_checksum(this, name);
if (!cs)
{
DBG1(" '%s' file checksum not found", name);
DBG1(DBG_LIB, " '%s' file checksum not found", name);
return FALSE;
}
sum = build_file(this, file, &len);
@ -202,17 +203,17 @@ static bool check_file(private_integrity_checker_t *this,
}
if (cs->file_len != len)
{
DBG1(" invalid '%s' file size: %u bytes, expected %u bytes",
DBG1(DBG_LIB, " invalid '%s' file size: %u bytes, expected %u bytes",
name, len, cs->file_len);
return FALSE;
}
if (cs->file != sum)
{
DBG1(" invalid '%s' file checksum: %08x, expected %08x",
DBG1(DBG_LIB, " invalid '%s' file checksum: %08x, expected %08x",
name, sum, cs->file);
return FALSE;
}
DBG2(" valid '%s' file checksum: %08x", name, sum);
DBG2(DBG_LIB, " valid '%s' file checksum: %08x", name, sum);
return TRUE;
}
@ -229,7 +230,7 @@ static bool check_segment(private_integrity_checker_t *this,
cs = find_checksum(this, name);
if (!cs)
{
DBG1(" '%s' segment checksum not found", name);
DBG1(DBG_LIB, " '%s' segment checksum not found", name);
return FALSE;
}
sum = build_segment(this, sym, &len);
@ -239,17 +240,17 @@ static bool check_segment(private_integrity_checker_t *this,
}
if (cs->segment_len != len)
{
DBG1(" invalid '%s' segment size: %u bytes, expected %u bytes",
name, len, cs->segment_len);
DBG1(DBG_LIB, " invalid '%s' segment size: %u bytes,"
" expected %u bytes", name, len, cs->segment_len);
return FALSE;
}
if (cs->segment != sum)
{
DBG1(" invalid '%s' segment checksum: %08x, expected %08x",
DBG1(DBG_LIB, " invalid '%s' segment checksum: %08x, expected %08x",
name, sum, cs->segment);
return FALSE;
}
DBG2(" valid '%s' segment checksum: %08x", name, sum);
DBG2(DBG_LIB, " valid '%s' segment checksum: %08x", name, sum);
return TRUE;
}
@ -262,7 +263,7 @@ static bool check(private_integrity_checker_t *this, char *name, void *sym)
if (dladdr(sym, &dli) == 0)
{
DBG1("unable to locate symbol: %s", dlerror());
DBG1(DBG_LIB, "unable to locate symbol: %s", dlerror());
return FALSE;
}
if (!check_file(this, name, (char*)dli.dli_fname))
@ -319,12 +320,14 @@ integrity_checker_t *integrity_checker_create(char *checksum_library)
}
else
{
DBG1("checksum library '%s' invalid", checksum_library);
DBG1(DBG_LIB, "checksum library '%s' invalid",
checksum_library);
}
}
else
{
DBG1("loading checksum library '%s' failed", checksum_library);
DBG1(DBG_LIB, "loading checksum library '%s' failed",
checksum_library);
}
}
return &this->public;

4
src/libstrongswan/library.c
View File

@ -141,11 +141,11 @@ bool library_init(char *settings)
this->public.integrity = integrity_checker_create(CHECKSUM_LIBRARY);
if (!lib->integrity->check(lib->integrity, "libstrongswan", library_init))
{
DBG1("integrity check of libstrongswan failed");
DBG1(DBG_LIB, "integrity check of libstrongswan failed");
return FALSE;
}
#else /* !INTEGRITY_TEST */
DBG1("integrity test enabled, but not supported");
DBG1(DBG_LIB, "integrity test enabled, but not supported");
return FALSE;
#endif /* INTEGRITY_TEST */
}

26
src/libstrongswan/plugins/agent/agent_private_key.c
View File

@ -137,7 +137,8 @@ static int open_connection(char *path)
s = socket(AF_UNIX, SOCK_STREAM, 0);
if (s == -1)
{
DBG1("opening ssh-agent socket %s failed: %s:", path, strerror(errno));
DBG1(DBG_LIB, "opening ssh-agent socket %s failed: %s:", path,
strerror(errno));
return -1;
}
@ -147,7 +148,8 @@ static int open_connection(char *path)
if (connect(s, (struct sockaddr*)&addr, SUN_LEN(&addr)) != 0)
{
DBG1("connecting to ssh-agent socket failed: %s", strerror(errno));
DBG1(DBG_LIB, "connecting to ssh-agent socket failed: %s",
strerror(errno));
close(s);
return -1;
}
@ -168,7 +170,7 @@ static bool read_key(private_agent_private_key_t *this, public_key_t *pubkey)
if (write(this->socket, &len, sizeof(len)) != sizeof(len) ||
write(this->socket, &buf, 1) != 1)
{
DBG1("writing to ssh-agent failed");
DBG1(DBG_LIB, "writing to ssh-agent failed");
return FALSE;
}
@ -179,7 +181,7 @@ static bool read_key(private_agent_private_key_t *this, public_key_t *pubkey)
read_uint32(&blob) != blob.len ||
read_byte(&blob) != SSH_AGENT_ID_RESPONSE)
{
DBG1("received invalid ssh-agent identity response");
DBG1(DBG_LIB, "received invalid ssh-agent identity response");
return FALSE;
}
count = read_uint32(&blob);
@ -231,7 +233,7 @@ static bool sign(private_agent_private_key_t *this, signature_scheme_t scheme,
if (scheme != SIGN_RSA_EMSA_PKCS1_SHA1)
{
DBG1("signature scheme %N not supported by ssh-agent",
DBG1(DBG_LIB, "signature scheme %N not supported by ssh-agent",
signature_scheme_names, scheme);
return FALSE;
}
@ -241,7 +243,7 @@ static bool sign(private_agent_private_key_t *this, signature_scheme_t scheme,
if (write(this->socket, &len, sizeof(len)) != sizeof(len) ||
write(this->socket, &buf, 1) != 1)
{
DBG1("writing to ssh-agent failed");
DBG1(DBG_LIB, "writing to ssh-agent failed");
return FALSE;
}
@ -249,7 +251,7 @@ static bool sign(private_agent_private_key_t *this, signature_scheme_t scheme,
if (write(this->socket, &len, sizeof(len)) != sizeof(len) ||
write(this->socket, this->key.ptr, this->key.len) != this->key.len)
{
DBG1("writing to ssh-agent failed");
DBG1(DBG_LIB, "writing to ssh-agent failed");
return FALSE;
}
@ -257,14 +259,14 @@ static bool sign(private_agent_private_key_t *this, signature_scheme_t scheme,
if (write(this->socket, &len, sizeof(len)) != sizeof(len) ||
write(this->socket, data.ptr, data.len) != data.len)
{
DBG1("writing to ssh-agent failed");
DBG1(DBG_LIB, "writing to ssh-agent failed");
return FALSE;
}
flags = htonl(0);
if (write(this->socket, &flags, sizeof(flags)) != sizeof(flags))
{
DBG1("writing to ssh-agent failed");
DBG1(DBG_LIB, "writing to ssh-agent failed");
return FALSE;
}
@ -274,7 +276,7 @@ static bool sign(private_agent_private_key_t *this, signature_scheme_t scheme,
read_uint32(&blob) != blob.len ||
read_byte(&blob) != SSH_AGENT_SIGN_RESPONSE)
{
DBG1("received invalid ssh-agent signature response");
DBG1(DBG_LIB, "received invalid ssh-agent signature response");
return FALSE;
}
/* parse length */
@ -285,7 +287,7 @@ static bool sign(private_agent_private_key_t *this, signature_scheme_t scheme,
blob = read_string(&blob);
if (!blob.len)
{
DBG1("received invalid ssh-agent signature response");
DBG1(DBG_LIB, "received invalid ssh-agent signature response");
return FALSE;
}
*signature = chunk_clone(blob);
@ -306,7 +308,7 @@ static key_type_t get_type(private_agent_private_key_t *this)
static bool decrypt(private_agent_private_key_t *this,
chunk_t crypto, chunk_t *plain)
{
DBG1("private key decryption not supported by ssh-agent");
DBG1(DBG_LIB, "private key decryption not supported by ssh-agent");
return FALSE;
}

4
src/libstrongswan/plugins/curl/curl_fetcher.c
View File

@ -84,7 +84,7 @@ METHOD(fetcher_t, fetch, status_t,
curl_easy_setopt(this->curl, CURLOPT_HTTPHEADER, this->headers);
}
DBG2(" sending http request to '%s'...", uri);
DBG2(DBG_LIB, " sending http request to '%s'...", uri);
switch (curl_easy_perform(this->curl))
{
case CURLE_UNSUPPORTED_PROTOCOL:
@ -94,7 +94,7 @@ METHOD(fetcher_t, fetch, status_t,
status = SUCCESS;
break;
default:
DBG1("libcurl http request failed: %s", error);
DBG1(DBG_LIB, "libcurl http request failed: %s", error);
status = FAILED;
break;
}

2
src/libstrongswan/plugins/curl/curl_plugin.c
View File

@ -69,7 +69,7 @@ plugin_t *curl_plugin_create()
}
else
{
DBG1("global libcurl initializing failed: %s, curl disabled",
DBG1(DBG_LIB, "global libcurl initializing failed: %s, curl disabled",
curl_easy_strerror(res));
}
return &this->public.plugin;

9
src/libstrongswan/plugins/dnskey/dnskey_builder.c
View File

@ -52,7 +52,7 @@ static dnskey_public_key_t *parse_public_key(chunk_t blob)
if (blob.len < sizeof(dnskey_rr_t))
{
DBG1("DNSKEY too short");
DBG1(DBG_LIB, "DNSKEY too short");
return NULL;
}
blob = chunk_skip(blob, sizeof(dnskey_rr_t));
@ -63,7 +63,8 @@ static dnskey_public_key_t *parse_public_key(chunk_t blob)
return lib->creds->create(lib->creds, CRED_PUBLIC_KEY, KEY_RSA,
BUILD_BLOB_DNSKEY, blob, BUILD_END);
default:
DBG1("DNSKEY public key algorithm %d not supported", rr->algorithm);
DBG1(DBG_LIB, "DNSKEY public key algorithm %d not supported",
rr->algorithm);
return NULL;
}
}
@ -77,7 +78,7 @@ static dnskey_public_key_t *parse_rsa_public_key(chunk_t blob)
if (blob.len < 3)
{
DBG1("RFC 3110 public key blob too short for exponent length");
DBG1(DBG_LIB, "RFC 3110 public key blob too short for exponent length");
return NULL;
}
@ -94,7 +95,7 @@ static dnskey_public_key_t *parse_rsa_public_key(chunk_t blob)
e.ptr = blob.ptr;
if (e.len >= blob.len)
{
DBG1("RFC 3110 public key blob too short for exponent");
DBG1(DBG_LIB, "RFC 3110 public key blob too short for exponent");
return NULL;
}
n = chunk_skip(blob, e.len);

6
src/libstrongswan/plugins/fips_prf/fips_prf.c
View File

@ -126,14 +126,14 @@ static void get_bytes(private_fips_prf_t *this, chunk_t seed, u_int8_t w[])
{
/* a. XVAL = (XKEY + XSEED j) mod 2^b */
add_mod(this->b, xkey, xseed, xval);
DBG3("XVAL %b", xval, this->b);
DBG3(DBG_LIB, "XVAL %b", xval, this->b);
/* b. wi = G(t, XVAL ) */
this->g(this, chunk_create(xval, this->b), &w[i * this->b]);
DBG3("w[%d] %b", i, &w[i * this->b], this->b);
DBG3(DBG_LIB, "w[%d] %b", i, &w[i * this->b], this->b);
/* c. XKEY = (1 + XKEY + wi) mod 2b */
add_mod(this->b, xkey, &w[i * this->b], sum);
add_mod(this->b, sum, one, xkey);
DBG3("XKEY %b", xkey, this->b);
DBG3(DBG_LIB, "XKEY %b", xkey, this->b);
}
/* 3.3 done already, mod q not used */

2
src/libstrongswan/plugins/gcrypt/gcrypt_crypter.c
View File

@ -234,7 +234,7 @@ gcrypt_crypter_t *gcrypt_crypter_create(encryption_algorithm_t algo,
err = gcry_cipher_open(&this->h, gcrypt_alg, mode, 0);
if (err)
{
DBG1("grcy_cipher_open(%N) failed: %s",
DBG1(DBG_LIB, "grcy_cipher_open(%N) failed: %s",
encryption_algorithm_names, algo, gpg_strerror(err));
free(this);
return NULL;

9
src/libstrongswan/plugins/gcrypt/gcrypt_dh.c
View File

@ -89,7 +89,7 @@ static void set_other_public_value(private_gcrypt_dh_t *this, chunk_t value)
err = gcry_mpi_scan(&this->yb, GCRYMPI_FMT_USG, value.ptr, value.len, NULL);
if (err)
{
DBG1("importing mpi yb failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "importing mpi yb failed: %s", gpg_strerror(err));
return;
}
@ -110,7 +110,8 @@ static void set_other_public_value(private_gcrypt_dh_t *this, chunk_t value)
}
else
{
DBG1("public DH value verification failed: y < 2 || y > p - 1 ");
DBG1(DBG_LIB, "public DH value verification failed:"
" y < 2 || y > p - 1 ");
}
gcry_mpi_release(p_min_1);
}
@ -207,7 +208,7 @@ gcrypt_dh_t *gcrypt_dh_create(diffie_hellman_group_t group)
params->prime, params->prime_len, NULL);
if (err)
{
DBG1("importing mpi modulus failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "importing mpi modulus failed: %s", gpg_strerror(err));
free(this);
return NULL;
}
@ -222,7 +223,7 @@ gcrypt_dh_t *gcrypt_dh_create(diffie_hellman_group_t group)
chunk_clear(&random);
if (err)
{
DBG1("importing mpi xa failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "importing mpi xa failed: %s", gpg_strerror(err));
gcry_mpi_release(this->p);
free(this);
return NULL;

2
src/libstrongswan/plugins/gcrypt/gcrypt_hasher.c
View File

@ -137,7 +137,7 @@ gcrypt_hasher_t *gcrypt_hasher_create(hash_algorithm_t algo)
err = gcry_md_open(&this->hd, gcrypt_alg, 0);
if (err)
{
DBG1("grcy_md_open(%N) failed: %s",
DBG1(DBG_LIB, "grcy_md_open(%N) failed: %s",
hash_algorithm_names, algo, gpg_strerror(err));
free(this);
return NULL;

2
src/libstrongswan/plugins/gcrypt/gcrypt_plugin.c
View File

@ -126,7 +126,7 @@ plugin_t *gcrypt_plugin_create()
if (!gcry_check_version(GCRYPT_VERSION))
{
DBG1("libgcrypt version mismatch");
DBG1(DBG_LIB, "libgcrypt version mismatch");
return NULL;
}

30
src/libstrongswan/plugins/gcrypt/gcrypt_rsa_private_key.c
View File

@ -130,14 +130,15 @@ static bool sign_raw(private_gcrypt_rsa_private_key_t *this,
chunk_free(&em);
if (err)
{
DBG1("building signature S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building signature S-expression failed: %s",
gpg_strerror(err));
return FALSE;
}
err = gcry_pk_sign(&out, in, this->key);
gcry_sexp_release(in);
if (err)
{
DBG1("creating pkcs1 signature failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "creating pkcs1 signature failed: %s", gpg_strerror(err));
return FALSE;
}
*signature = gcrypt_rsa_find_token(out, "s", this->key);
@ -176,14 +177,14 @@ static bool sign_pkcs1(private_gcrypt_rsa_private_key_t *this,
chunk_free(&hash);
if (err)
{
DBG1("building signature S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building signature S-expression failed: %s", gpg_strerror(err));
return FALSE;
}
err = gcry_pk_sign(&out, in, this->key);
gcry_sexp_release(in);
if (err)
{
DBG1("creating pkcs1 signature failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "creating pkcs1 signature failed: %s", gpg_strerror(err));
return FALSE;
}
*signature = gcrypt_rsa_find_token(out, "s", this->key);
@ -222,7 +223,7 @@ static bool sign(private_gcrypt_rsa_private_key_t *this, signature_scheme_t sche
case SIGN_RSA_EMSA_PKCS1_MD5:
return sign_pkcs1(this, HASH_MD5, "md5", data, sig);
default:
DBG1("signature scheme %N not supported in RSA",
DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
signature_scheme_names, scheme);
return FALSE;
}
@ -243,14 +244,15 @@ static bool decrypt(private_gcrypt_rsa_private_key_t *this,
encrypted.len, encrypted.ptr);
if (err)
{
DBG1("building decryption S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building decryption S-expression failed: %s",
gpg_strerror(err));
return FALSE;
}
err = gcry_pk_decrypt(&out, in, this->key);
gcry_sexp_release(in);
if (err)
{
DBG1("decrypting pkcs1 data failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "decrypting pkcs1 data failed: %s", gpg_strerror(err));
return FALSE;
}
padded.ptr = (u_char*)gcry_sexp_nth_data(out, 1, &padded.len);
@ -269,7 +271,7 @@ static bool decrypt(private_gcrypt_rsa_private_key_t *this,
gcry_sexp_release(out);
if (!pos)
{
DBG1("decrypted data has invalid pkcs1 padding");
DBG1(DBG_LIB, "decrypted data has invalid pkcs1 padding");
return FALSE;
}
return TRUE;
@ -329,7 +331,7 @@ static bool get_encoding(private_gcrypt_rsa_private_key_t *this,
chunk_clear(&cp);
chunk_clear(&cq);
chunk_clear(&cd);
DBG1("scanning mpi for export failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "scanning mpi for export failed: %s", gpg_strerror(err));
return FALSE;
}
@ -352,7 +354,7 @@ static bool get_encoding(private_gcrypt_rsa_private_key_t *this,
if (err)
{
DBG1("printing mpi for export failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "printing mpi for export failed: %s", gpg_strerror(err));
chunk_clear(&cp);
chunk_clear(&cq);
chunk_clear(&cd);
@ -488,7 +490,7 @@ gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_gen(key_type_t type,
err = gcry_sexp_build(&param, NULL, "(genkey(rsa(nbits %d)))", key_size);
if (err)
{
DBG1("building S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building S-expression failed: %s", gpg_strerror(err));
return NULL;
}
this = gcrypt_rsa_private_key_create_empty();
@ -497,7 +499,7 @@ gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_gen(key_type_t type,
if (err)
{
free(this);
DBG1("generating RSA key failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "generating RSA key failed: %s", gpg_strerror(err));
return NULL;
}
return &this->public;
@ -557,14 +559,14 @@ gcrypt_rsa_private_key_t *gcrypt_rsa_private_key_load(key_type_t type,
p.len, p.ptr, q.len, q.ptr, u.len, u.ptr);
if (err)
{
DBG1("loading private key failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "loading private key failed: %s", gpg_strerror(err));
free(this);
return NULL;
}
err = gcry_pk_testkey(this->key);
if (err)
{
DBG1("private key sanity check failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "private key sanity check failed: %s", gpg_strerror(err));
destroy(this);
return NULL;
}

28
src/libstrongswan/plugins/gcrypt/gcrypt_rsa_public_key.c
View File

@ -83,14 +83,16 @@ static bool verify_raw(private_gcrypt_rsa_public_key_t *this,
chunk_free(&em);
if (err)
{
DBG1("building data S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building data S-expression failed: %s",
gpg_strerror(err));
return FALSE;
}
err = gcry_sexp_build(&sig, NULL, "(sig-val(rsa(s %b)))",
signature.len, signature.ptr);
if (err)
{
DBG1("building signature S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building signature S-expression failed: %s",
gpg_strerror(err));
gcry_sexp_release(in);
return FALSE;
}
@ -99,7 +101,8 @@ static bool verify_raw(private_gcrypt_rsa_public_key_t *this,
gcry_sexp_release(sig);
if (err)
{
DBG1("RSA signature verification failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "RSA signature verification failed: %s",
gpg_strerror(err));
return FALSE;
}
return TRUE;
@ -130,7 +133,8 @@ static bool verify_pkcs1(private_gcrypt_rsa_public_key_t *this,
chunk_free(&hash);
if (err)
{
DBG1("building data S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building data S-expression failed: %s",
gpg_strerror(err));
return FALSE;
}
@ -138,7 +142,8 @@ static bool verify_pkcs1(private_gcrypt_rsa_public_key_t *this,
signature.len, signature.ptr);
if (err)
{
DBG1("building signature S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building signature S-expression failed: %s",
gpg_strerror(err));
gcry_sexp_release(in);
return FALSE;
}
@ -147,7 +152,8 @@ static bool verify_pkcs1(private_gcrypt_rsa_public_key_t *this,
gcry_sexp_release(sig);
if (err)
{
DBG1("RSA signature verification failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "RSA signature verification failed: %s",
gpg_strerror(err));
return FALSE;
}
return TRUE;
@ -184,7 +190,7 @@ static bool verify(private_gcrypt_rsa_public_key_t *this,
case SIGN_RSA_EMSA_PKCS1_SHA512:
return verify_pkcs1(this, HASH_SHA512, "sha512", data, signature);
default:
DBG1("signature scheme %N not supported in RSA",
DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
signature_scheme_names, scheme);
return FALSE;
}
@ -205,14 +211,16 @@ static bool encrypt_(private_gcrypt_rsa_public_key_t *this, chunk_t plain,
plain.len, plain.ptr);
if (err)
{
DBG1("building encryption S-expression failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "building encryption S-expression failed: %s",
gpg_strerror(err));
return FALSE;
}
err = gcry_pk_encrypt(&out, in, this->key);
gcry_sexp_release(in);
if (err)
{
DBG1("encrypting data using pkcs1 failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "encrypting data using pkcs1 failed: %s",
gpg_strerror(err));
return FALSE;
}
*encrypted = gcrypt_rsa_find_token(out, "a", this->key);
@ -343,7 +351,7 @@ gcrypt_rsa_public_key_t *gcrypt_rsa_public_key_load(key_type_t type,
n.len, n.ptr, e.len, e.ptr);
if (err)
{
DBG1("loading public key failed: %s", gpg_strerror(err));
DBG1(DBG_LIB, "loading public key failed: %s", gpg_strerror(err));
free(this);
return NULL;
}

12
src/libstrongswan/plugins/gmp/gmp_diffie_hellman.c
View File

@ -119,7 +119,8 @@ static void set_other_public_value(private_gmp_diffie_hellman_t *this, chunk_t v
}
else
{
DBG1("public DH value verification failed: y ^ q mod p != 1");
DBG1(DBG_LIB, "public DH value verification failed:"
" y ^ q mod p != 1");
}
mpz_clear(one);
#else
@ -129,7 +130,8 @@ static void set_other_public_value(private_gmp_diffie_hellman_t *this, chunk_t v
}
else
{
DBG1("public DH value verification failed: y < 2 || y > p - 1 ");
DBG1(DBG_LIB, "public DH value verification failed:"
" y < 2 || y > p - 1 ");
}
mpz_clear(p_min_1);
}
@ -228,7 +230,8 @@ gmp_diffie_hellman_t *gmp_diffie_hellman_create(diffie_hellman_group_t group)
rng = lib->crypto->create_rng(lib->crypto, RNG_STRONG);
if (!rng)
{
DBG1("no RNG found for quality %N", rng_quality_names, RNG_STRONG);
DBG1(DBG_LIB, "no RNG found for quality %N", rng_quality_names,
RNG_STRONG);
destroy(this);
return NULL;
}
@ -243,7 +246,8 @@ gmp_diffie_hellman_t *gmp_diffie_hellman_create(diffie_hellman_group_t group)
}
mpz_import(this->xa, random.len, 1, 1, 1, 0, random.ptr);
chunk_free(&random);
DBG2("size of DH secret exponent: %u bits", mpz_sizeinbase(this->xa, 2));
DBG2(DBG_LIB, "size of DH secret exponent: %u bits",
mpz_sizeinbase(this->xa, 2));
mpz_powm(this->ya, this->g, this->xa, this->p);

20
src/libstrongswan/plugins/gmp/gmp_rsa_private_key.c
View File

@ -141,7 +141,8 @@ static status_t compute_prime(private_gmp_rsa_private_key_t *this,
rng = lib->crypto->create_rng(lib->crypto, RNG_TRUE);
if (!rng)
{
DBG1("no RNG of quality %N found", rng_quality_names, RNG_TRUE);
DBG1(DBG_LIB, "no RNG of quality %N found", rng_quality_names,
RNG_TRUE);
return FAILED;
}
@ -248,7 +249,8 @@ static bool build_emsa_pkcs1_signature(private_gmp_rsa_private_key_t *this,
if (data.len > this->k - 3)
{
free(digestInfo.ptr);
DBG1("unable to sign %d bytes using a %dbit key", data.len, this->k * 8);
DBG1(DBG_LIB, "unable to sign %d bytes using a %dbit key", data.len,
this->k * 8);
return FALSE;
}
@ -309,7 +311,7 @@ static bool sign(private_gmp_rsa_private_key_t *this, signature_scheme_t scheme,
case SIGN_RSA_EMSA_PKCS1_MD5:
return build_emsa_pkcs1_signature(this, HASH_MD5, data, signature);
default:
DBG1("signature scheme %N not supported in RSA",
DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
signature_scheme_names, scheme);
return FALSE;
}
@ -332,7 +334,7 @@ static bool decrypt(private_gmp_rsa_private_key_t *this, chunk_t crypto,
/* check for hex pattern 00 02 in decrypted message */
if ((*stripped.ptr++ != 0x00) || (*(stripped.ptr++) != 0x02))
{
DBG1("incorrect padding - probably wrong rsa key");
DBG1(DBG_LIB, "incorrect padding - probably wrong rsa key");
goto end;
}
stripped.len -= 2;
@ -342,7 +344,7 @@ static bool decrypt(private_gmp_rsa_private_key_t *this, chunk_t crypto,
if (stripped.len == 0)
{
DBG1("no plaintext data");
DBG1(DBG_LIB, "no plaintext data");
goto end;
}
@ -514,14 +516,14 @@ static status_t check(private_gmp_rsa_private_key_t *this)
*/
if (this->k < 512 / BITS_PER_BYTE)
{
DBG1("key shorter than 512 bits");
DBG1(DBG_LIB, "key shorter than 512 bits");
return FAILED;
}
/* we picked a max modulus size to simplify buffer allocation */
if (this->k > 8192 / BITS_PER_BYTE)
{
DBG1("key larger than 8192 bits");
DBG1(DBG_LIB, "key larger than 8192 bits");
return FAILED;
}
@ -595,7 +597,7 @@ static status_t check(private_gmp_rsa_private_key_t *this)
mpz_clear_sensitive(q1);
if (status != SUCCESS)
{
DBG1("key integrity tests failed");
DBG1(DBG_LIB, "key integrity tests failed");
}
return status;
}
@ -684,7 +686,7 @@ gmp_rsa_private_key_t *gmp_rsa_private_key_gen(key_type_t type, va_list args)
mpz_mul(n, p, q); /* n = p*q */
mpz_init_set_ui(e, PUBLIC_EXPONENT); /* assign public exponent */
mpz_init_set(m, p); /* m = p */
mpz_init_set(m, p); /* m = p */
mpz_sub_ui(m, m, 1); /* m = m -1 */
mpz_init_set(q1, q); /* q1 = q */
mpz_sub_ui(q1, q1, 1); /* q1 = q1 -1 */

35
src/libstrongswan/plugins/gmp/gmp_rsa_public_key.c
View File

@ -183,8 +183,8 @@ static bool verify_emsa_pkcs1_signature(private_gmp_rsa_public_key_t *this,
{ /* IKEv1 signatures without digestInfo */
if (em.len != data.len)
{
DBG1("hash size in signature is %u bytes instead of %u bytes",
em.len, data.len);
DBG1(DBG_LIB, "hash size in signature is %u bytes instead of"
" %u bytes", em.len, data.len);
goto end;
}
success = memeq(em.ptr, data.ptr, data.len);
@ -196,7 +196,7 @@ static bool verify_emsa_pkcs1_signature(private_gmp_rsa_public_key_t *this,
int objectID;
hash_algorithm_t hash_algorithm = HASH_UNKNOWN;
DBG2("signature verification:");
DBG2(DBG_LIB, "signature verification:");
parser = asn1_parser_create(digestInfoObjects, em);
while (parser->iterate(parser, &objectID, &object))
@ -207,7 +207,8 @@ static bool verify_emsa_pkcs1_signature(private_gmp_rsa_public_key_t *this,
{
if (em.len > object.len)
{
DBG1("digestInfo field in signature is followed by %u surplus bytes",
DBG1(DBG_LIB, "digestInfo field in signature is"
" followed by %u surplus bytes",
em.len - object.len);
goto end_parser;
}
@ -221,8 +222,8 @@ static bool verify_emsa_pkcs1_signature(private_gmp_rsa_public_key_t *this,
hash_algorithm = hasher_algorithm_from_oid(hash_oid);
if (hash_algorithm == HASH_UNKNOWN || hash_algorithm != algorithm)
{
DBG1("expected hash algorithm %N, but found %N (OID: %#B)",
hash_algorithm_names, algorithm,
DBG1(DBG_LIB, "expected hash algorithm %N, but found"
" %N (OID: %#B)", hash_algorithm_names, algorithm,
hash_algorithm_names, hash_algorithm, &object);
goto end_parser;
}
@ -236,15 +237,16 @@ static bool verify_emsa_pkcs1_signature(private_gmp_rsa_public_key_t *this,
hasher = lib->crypto->create_hasher(lib->crypto, hash_algorithm);
if (hasher == NULL)
{
DBG1("hash algorithm %N not supported",
DBG1(DBG_LIB, "hash algorithm %N not supported",
hash_algorithm_names, hash_algorithm);
goto end_parser;
}
if (object.len != hasher->get_hash_size(hasher))
{
DBG1("hash size in signature is %u bytes instead of %u "
"bytes", object.len, hasher->get_hash_size(hasher));
DBG1(DBG_LIB, "hash size in signature is %u bytes"
" instead of %u bytes", object.len,
hasher->get_hash_size(hasher));
hasher->destroy(hasher);
goto end_parser;
}
@ -302,7 +304,7 @@ static bool verify(private_gmp_rsa_public_key_t *this, signature_scheme_t scheme
case SIGN_RSA_EMSA_PKCS1_SHA512:
return verify_emsa_pkcs1_signature(this, HASH_SHA512, data, signature);
default:
DBG1("signature scheme %N not supported in RSA",
DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
signature_scheme_names, scheme);
return FALSE;
}
@ -324,7 +326,7 @@ static bool encrypt_(private_gmp_rsa_public_key_t *this, chunk_t plain,
rng = lib->crypto->create_rng(lib->crypto, RNG_WEAK);
if (rng == NULL)
{
DBG1("no random generator available");
DBG1(DBG_LIB, "no random generator available");
return FALSE;
}
@ -332,13 +334,14 @@ static bool encrypt_(private_gmp_rsa_public_key_t *this, chunk_t plain,
padding = this->k - plain.len - 3;
if (padding < MIN_PS_PADDING)
{
DBG1("pseudo-random padding must be at least %d octets", MIN_PS_PADDING);
DBG1(DBG_LIB, "pseudo-random padding must be at least %d octets",
MIN_PS_PADDING);
return FALSE;
}
/* padding according to PKCS#1 7.2.1 (RSAES-PKCS1-v1.5-ENCRYPT) */
DBG2("padding %u bytes of data to the rsa modulus size of %u bytes",
plain.len, this->k);
DBG2(DBG_LIB, "padding %u bytes of data to the rsa modulus size of"
" %u bytes", plain.len, this->k);
em.len = this->k;
em.ptr = malloc(em.len);
pos = em.ptr;
@ -364,11 +367,11 @@ static bool encrypt_(private_gmp_rsa_public_key_t *this, chunk_t plain,
/* now add the data */
memcpy(pos, plain.ptr, plain.len);
DBG3("padded data before rsa encryption: %B", &em);
DBG3(DBG_LIB, "padded data before rsa encryption: %B", &em);
/* rsa encryption using PKCS#1 RSAEP */
*crypto = rsaep(this, em);
DBG3("rsa encrypted data: %B", crypto);
DBG3(DBG_LIB, "rsa encrypted data: %B", crypto);
chunk_clear(&em);
return TRUE;
}

17
src/libstrongswan/plugins/ldap/ldap_fetcher.c
View File

@ -73,27 +73,27 @@ static bool parse(LDAP *ldap, LDAPMessage *result, chunk_t *response)
}
else
{
DBG1("LDAP response contains no values");
DBG1(DBG_LIB, "LDAP response contains no values");
}
ldap_value_free_len(values);
}
else
{
DBG1("getting LDAP values failed: %s",
DBG1(DBG_LIB, "getting LDAP values failed: %s",
ldap_err2string(ldap_result2error(ldap, entry, 0)));
}
ldap_memfree(attr);
}
else
{
DBG1("finding LDAP attributes failed: %s",
DBG1(DBG_LIB, "finding LDAP attributes failed: %s",
ldap_err2string(ldap_result2error(ldap, entry, 0)));
}
ber_free(ber, 0);
}
else
{
DBG1("finding first LDAP entry failed: %s",
DBG1(DBG_LIB, "finding first LDAP entry failed: %s",
ldap_err2string(ldap_result2error(ldap, entry, 0)));
}
return success;
@ -122,7 +122,7 @@ static status_t fetch(private_ldap_fetcher_t *this, char *url,
ldap = ldap_init(lurl->lud_host, lurl->lud_port);
if (ldap == NULL)
{
DBG1("LDAP initialization failed: %s", strerror(errno));
DBG1(DBG_LIB, "LDAP initialization failed: %s", strerror(errno));
ldap_free_urldesc(lurl);
return FAILED;
}
@ -133,7 +133,7 @@ static status_t fetch(private_ldap_fetcher_t *this, char *url,
ldap_set_option(ldap, LDAP_OPT_PROTOCOL_VERSION, &ldap_version);
ldap_set_option(ldap, LDAP_OPT_NETWORK_TIMEOUT, &timeout);
DBG2("sending LDAP request to '%s'...", url);
DBG2(DBG_LIB, "sending LDAP request to '%s'...", url);
res = ldap_simple_bind_s(ldap, NULL, NULL);
if (res == LDAP_SUCCESS)
@ -152,12 +152,13 @@ static status_t fetch(private_ldap_fetcher_t *this, char *url,
}
else
{
DBG1("LDAP search failed: %s", ldap_err2string(res));
DBG1(DBG_LIB, "LDAP search failed: %s", ldap_err2string(res));
}
}
else
{
DBG1("LDAP bind to '%s' failed: %s", url, ldap_err2string(res));
DBG1(DBG_LIB, "LDAP bind to '%s' failed: %s", url,
ldap_err2string(res));
}
ldap_unbind_s(ldap);
ldap_free_urldesc(lurl);

28
src/libstrongswan/plugins/mysql/mysql_database.c
View File

@ -203,7 +203,7 @@ static conn_t *conn_get(private_mysql_database_t *this)
this->password, this->database, this->port,
NULL, 0))
{
DBG1("connecting to mysql://%s:***@%s:%d/%s failed: %s",
DBG1(DBG_LIB, "connecting to mysql://%s:***@%s:%d/%s failed: %s",
this->username, this->host, this->port, this->database,
mysql_error(found->mysql));
conn_destroy(found);
@ -213,7 +213,7 @@ static conn_t *conn_get(private_mysql_database_t *this)
{
this->mutex->lock(this->mutex);
this->pool->insert_last(this->pool, found);
DBG2("increased MySQL connection pool size to %d",
DBG2(DBG_LIB, "increased MySQL connection pool size to %d",
this->pool->get_count(this->pool));
this->mutex->unlock(this->mutex);
}
@ -232,12 +232,14 @@ static MYSQL_STMT* run(MYSQL *mysql, char *sql, va_list *args)
stmt = mysql_stmt_init(mysql);
if (stmt == NULL)
{
DBG1("creating MySQL statement failed: %s", mysql_error(mysql));
DBG1(DBG_LIB, "creating MySQL statement failed: %s",
mysql_error(mysql));
return NULL;
}
if (mysql_stmt_prepare(stmt, sql, strlen(sql)))
{
DBG1("preparing MySQL statement failed: %s", mysql_stmt_error(stmt));
DBG1(DBG_LIB, "preparing MySQL statement failed: %s",
mysql_stmt_error(stmt));
mysql_stmt_close(stmt);
return NULL;
}
@ -303,21 +305,23 @@ static MYSQL_STMT* run(MYSQL *mysql, char *sql, va_list *args)
break;
}
default:
DBG1("invalid data type supplied");
DBG1(DBG_LIB, "invalid data type supplied");
mysql_stmt_close(stmt);
return NULL;
}
}
if (mysql_stmt_bind_param(stmt, bind))
{
DBG1("binding MySQL param failed: %s", mysql_stmt_error(stmt));
DBG1(DBG_LIB, "binding MySQL param failed: %s",
mysql_stmt_error(stmt));
mysql_stmt_close(stmt);
return NULL;
}
}
if (mysql_stmt_execute(stmt))
{
DBG1("executing MySQL statement failed: %s", mysql_stmt_error(stmt));
DBG1(DBG_LIB, "executing MySQL statement failed: %s",
mysql_stmt_error(stmt));
mysql_stmt_close(stmt);
return NULL;
}
@ -413,7 +417,8 @@ static bool mysql_enumerator_enumerate(mysql_enumerator_t *this, ...)
case MYSQL_NO_DATA:
return FALSE;
default:
DBG1("fetching MySQL row failed: %s", mysql_stmt_error(this->stmt));
DBG1(DBG_LIB, "fetching MySQL row failed: %s",
mysql_stmt_error(this->stmt));
return FALSE;
}
@ -536,7 +541,7 @@ static enumerator_t* query(private_mysql_database_t *this, char *sql, ...)
break;
}
default:
DBG1("invalid result data type supplied");
DBG1(DBG_LIB, "invalid result data type supplied");
mysql_enumerator_destroy(enumerator);
va_end(args);
return NULL;
@ -544,7 +549,8 @@ static enumerator_t* query(private_mysql_database_t *this, char *sql, ...)
}
if (mysql_stmt_bind_result(stmt, enumerator->bind))
{
DBG1("binding MySQL result failed: %s", mysql_stmt_error(stmt));
DBG1(DBG_LIB, "binding MySQL result failed: %s",
mysql_stmt_error(stmt));
mysql_enumerator_destroy(enumerator);
enumerator = NULL;
}
@ -653,7 +659,7 @@ static bool parse_uri(private_mysql_database_t *this, char *uri)
}
}
}
DBG1("parsing MySQL database uri '%s' failed", uri);
DBG1(DBG_LIB, "parsing MySQL database uri '%s' failed", uri);
return FALSE;
}

2
src/libstrongswan/plugins/mysql/mysql_plugin.c
View File

@ -52,7 +52,7 @@ plugin_t *mysql_plugin_create()
if (!mysql_database_init())
{
DBG1("MySQL client library initialization failed");
DBG1(DBG_LIB, "MySQL client library initialization failed");
return NULL;
}

5
src/libstrongswan/plugins/openssl/openssl_diffie_hellman.c
View File

@ -103,7 +103,7 @@ static void set_other_public_value(private_openssl_diffie_hellman_t *this,
len = DH_compute_key(this->shared_secret.ptr, this->pub_key, this->dh);
if (len < 0)
{
DBG1("DH shared secret computation failed");
DBG1(DBG_LIB, "DH shared secret computation failed");
return;
}
this->shared_secret.len = len;
@ -187,7 +187,8 @@ openssl_diffie_hellman_t *openssl_diffie_hellman_create(diffie_hellman_group_t g
destroy(this);
return NULL;
}
DBG2("size of DH secret exponent: %d bits", BN_num_bits(this->dh->priv_key));
DBG2(DBG_LIB, "size of DH secret exponent: %d bits",
BN_num_bits(this->dh->priv_key));
return &this->public;
}

4
src/libstrongswan/plugins/openssl/openssl_ec_diffie_hellman.c
View File

@ -212,14 +212,14 @@ static void set_other_public_value(private_openssl_ec_diffie_hellman_t *this, ch
{
if (!chunk2ecp(this->ec_group, value, this->pub_key))
{
DBG1("ECDH public value is malformed");
DBG1(DBG_LIB, "ECDH public value is malformed");
return;
}
chunk_free(&this->shared_secret);
if (!compute_shared_key(this, &this->shared_secret)) {
DBG1("ECDH shared secret computation failed");
DBG1(DBG_LIB, "ECDH shared secret computation failed");
return;
}

12
src/libstrongswan/plugins/openssl/openssl_ec_private_key.c
View File

@ -84,14 +84,14 @@ static bool build_curve_signature(private_openssl_ec_private_key_t *this,
req_group = EC_GROUP_new_by_curve_name(nid_curve);
if (!req_group)
{
DBG1("signature scheme %N not supported in EC (required curve "
DBG1(DBG_LIB, "signature scheme %N not supported in EC (required curve "
"not supported)", signature_scheme_names, scheme);
return FALSE;
}
my_group = EC_KEY_get0_group(this->ec);
if (EC_GROUP_cmp(my_group, req_group, NULL) != 0)
{
DBG1("signature scheme %N not supported by private key",
DBG1(DBG_LIB, "signature scheme %N not supported by private key",
signature_scheme_names, scheme);
return FALSE;
}
@ -162,7 +162,7 @@ static bool sign(private_openssl_ec_private_key_t *this,
return build_curve_signature(this, scheme, NID_sha512,
NID_secp521r1, data, signature);
default:
DBG1("signature scheme %N not supported",
DBG1(DBG_LIB, "signature scheme %N not supported",
signature_scheme_names, scheme);
return FALSE;
}
@ -174,7 +174,7 @@ static bool sign(private_openssl_ec_private_key_t *this,
static bool decrypt(private_openssl_ec_private_key_t *this,
chunk_t crypto, chunk_t *plain)
{
DBG1("EC private key decryption not implemented");
DBG1(DBG_LIB, "EC private key decryption not implemented");
return FALSE;
}
@ -348,13 +348,13 @@ openssl_ec_private_key_t *openssl_ec_private_key_gen(key_type_t type,
this->ec = EC_KEY_new_by_curve_name(NID_secp521r1);
break;
default:
DBG1("EC private key size %d not supported", key_size);
DBG1(DBG_LIB, "EC private key size %d not supported", key_size);
destroy(this);
return NULL;
}
if (EC_KEY_generate_key(this->ec) != 1)
{
DBG1("EC private key generation failed", key_size);
DBG1(DBG_LIB, "EC private key generation failed", key_size);
destroy(this);
return NULL;
}

10
src/libstrongswan/plugins/openssl/openssl_ec_public_key.c
View File

@ -82,14 +82,14 @@ static bool verify_curve_signature(private_openssl_ec_public_key_t *this,
req_group = EC_GROUP_new_by_curve_name(nid_curve);
if (!req_group)
{
DBG1("signature scheme %N not supported in EC (required curve "
DBG1(DBG_LIB, "signature scheme %N not supported in EC (required curve "
"not supported)", signature_scheme_names, scheme);
return FALSE;
}
my_group = EC_KEY_get0_group(this->ec);
if (EC_GROUP_cmp(my_group, req_group, NULL) != 0)
{
DBG1("signature scheme %N not supported by private key",
DBG1(DBG_LIB, "signature scheme %N not supported by private key",
signature_scheme_names, scheme);
return FALSE;
}
@ -162,7 +162,7 @@ static bool verify(private_openssl_ec_public_key_t *this,
return verify_curve_signature(this, scheme, NID_sha512,
NID_secp521r1, data, signature);
default:
DBG1("signature scheme %N not supported in EC",
DBG1(DBG_LIB, "signature scheme %N not supported in EC",
signature_scheme_names, scheme);
return FALSE;
}
@ -174,7 +174,7 @@ static bool verify(private_openssl_ec_public_key_t *this,
static bool encrypt_(private_openssl_ec_public_key_t *this,
chunk_t crypto, chunk_t *plain)
{
DBG1("EC public key encryption not implemented");
DBG1(DBG_LIB, "EC public key encryption not implemented");
return FALSE;
}
@ -217,7 +217,7 @@ bool openssl_ec_fingerprint(EC_KEY *ec, key_encoding_type_t type, chunk_t *fp)
hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
if (!hasher)
{
DBG1("SHA1 hash algorithm not supported, fingerprinting failed");
DBG1(DBG_LIB, "SHA1 hash algorithm not supported, fingerprinting failed");
free(key.ptr);
return FALSE;
}

14
src/libstrongswan/plugins/openssl/openssl_rsa_private_key.c
View File

@ -160,7 +160,7 @@ static bool sign(private_openssl_rsa_private_key_t *this, signature_scheme_t sch
case SIGN_RSA_EMSA_PKCS1_MD5:
return build_emsa_pkcs1_signature(this, NID_md5, data, signature);
default:
DBG1("signature scheme %N not supported in RSA",
DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
signature_scheme_names, scheme);
return FALSE;
}
@ -172,7 +172,7 @@ static bool sign(private_openssl_rsa_private_key_t *this, signature_scheme_t sch
static bool decrypt(private_openssl_rsa_private_key_t *this,
chunk_t crypto, chunk_t *plain)
{
DBG1("RSA private key decryption not implemented");
DBG1(DBG_LIB, "RSA private key decryption not implemented");
return FALSE;
}
@ -480,18 +480,18 @@ openssl_rsa_private_key_t *openssl_rsa_private_key_connect(key_type_t type,
engine = ENGINE_by_id(engine_id);
if (!engine)
{
DBG1("engine '%s' is not available", engine_id);
DBG1(DBG_LIB, "engine '%s' is not available", engine_id);
return NULL;
}
if (!ENGINE_init(engine))
{
DBG1("failed to initialize engine '%s'", engine_id);
DBG1(DBG_LIB, "failed to initialize engine '%s'", engine_id);
ENGINE_free(engine);
return NULL;
}
if (!ENGINE_ctrl_cmd_string(engine, "PIN", pin, 0))
{
DBG1("failed to set PIN on engine '%s'", engine_id);
DBG1(DBG_LIB, "failed to set PIN on engine '%s'", engine_id);
ENGINE_free(engine);
return NULL;
}
@ -499,8 +499,8 @@ openssl_rsa_private_key_t *openssl_rsa_private_key_connect(key_type_t type,
key = ENGINE_load_private_key(engine, keyid, NULL, NULL);
if (!key)
{
DBG1("failed to load private key with ID '%s' from engine '%s'",
keyid, engine_id);
DBG1(DBG_LIB, "failed to load private key with ID '%s' from "
"engine '%s'", keyid, engine_id);
ENGINE_free(engine);
return NULL;
}

6
src/libstrongswan/plugins/openssl/openssl_rsa_public_key.c
View File

@ -145,7 +145,7 @@ static bool verify(private_openssl_rsa_public_key_t *this, signature_scheme_t sc
case SIGN_RSA_EMSA_PKCS1_MD5:
return verify_emsa_pkcs1_signature(this, NID_md5, data, signature);
default:
DBG1("signature scheme %N not supported in RSA",
DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
signature_scheme_names, scheme);
return FALSE;
}
@ -157,7 +157,7 @@ static bool verify(private_openssl_rsa_public_key_t *this, signature_scheme_t sc
static bool encrypt_(private_openssl_rsa_public_key_t *this,
chunk_t crypto, chunk_t *plain)
{
DBG1("RSA public key encryption not implemented");
DBG1(DBG_LIB, "RSA public key encryption not implemented");
return FALSE;
}
@ -200,7 +200,7 @@ bool openssl_rsa_fingerprint(RSA *rsa, key_encoding_type_t type, chunk_t *fp)
hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
if (!hasher)
{
DBG1("SHA1 hash algorithm not supported, fingerprinting failed");
DBG1(DBG_LIB, "SHA1 hash algorithm not supported, fingerprinting failed");
free(key.ptr);
return FALSE;
}

4
src/libstrongswan/plugins/padlock/padlock_plugin.c
View File

@ -97,7 +97,7 @@ static padlock_feature_t get_padlock_features()
return d;
}
}
DBG1("Padlock not found, CPU is %s", vendor);
DBG1(DBG_LIB, "Padlock not found, CPU is %s", vendor);
return 0;
}
@ -143,7 +143,7 @@ plugin_t *padlock_plugin_create()
free(this);
return NULL;
}
DBG1("Padlock found, supports:%s%s%s%s%s, enabled:%s%s%s%s%s",
DBG1(DBG_LIB, "Padlock found, supports:%s%s%s%s%s, enabled:%s%s%s%s%s",
this->features & PADLOCK_RNG_AVAILABLE ? " RNG" : "",
this->features & PADLOCK_ACE_AVAILABLE ? " ACE" : "",
this->features & PADLOCK_ACE2_AVAILABLE ? " ACE2" : "",

35
src/libstrongswan/plugins/pem/pem_builder.c
View File

@ -73,7 +73,7 @@ static bool find_boundary(char* tag, chunk_t *line)
{
if (present("-----", line))
{
DBG2(" -----%s %.*s-----", tag, (int)name.len, name.ptr);
DBG2(DBG_LIB, " -----%s %.*s-----", tag, (int)name.len, name.ptr);
return TRUE;
}
line->ptr++; line->len--; name.len++;
@ -99,7 +99,7 @@ static status_t pem_decrypt(chunk_t *blob, encryption_algorithm_t alg,
hasher = lib->crypto->create_hasher(lib->crypto, HASH_MD5);
if (hasher == NULL)
{
DBG1(" MD5 hash algorithm not available");
DBG1(DBG_LIB, " MD5 hash algorithm not available");
return NOT_SUPPORTED;
}
hash.len = hasher->get_hash_size(hasher);
@ -121,7 +121,7 @@ static status_t pem_decrypt(chunk_t *blob, encryption_algorithm_t alg,
crypter = lib->crypto->create_crypter(lib->crypto, alg, key_size);
if (crypter == NULL)
{
DBG1(" %N encryption algorithm not available",
DBG1(DBG_LIB, " %N encryption algorithm not available",
encryption_algorithm_names, alg);
return NOT_SUPPORTED;
}
@ -131,7 +131,7 @@ static status_t pem_decrypt(chunk_t *blob, encryption_algorithm_t alg,
blob->len % iv.len)
{
crypter->destroy(crypter);
DBG1(" data size is not multiple of block size");
DBG1(DBG_LIB, " data size is not multiple of block size");
return PARSE_ERROR;
}
crypter->decrypt(crypter, *blob, iv, &decrypted);
@ -155,7 +155,7 @@ static status_t pem_decrypt(chunk_t *blob, encryption_algorithm_t alg,
{
if (*last_padding_pos != padding)
{
DBG1(" invalid passphrase");
DBG1(DBG_LIB, " invalid passphrase");
return INVALID_ARG;
}
}
@ -234,7 +234,7 @@ static status_t pem_to_bin(chunk_t *blob, chunk_t(*cb)(void*,int), void *cb_data
}
/* we are looking for a parameter: value pair */
DBG2(" %.*s", (int)line.len, line.ptr);
DBG2(DBG_LIB, " %.*s", (int)line.len, line.ptr);
ugh = extract_parameter_value(&name, &value, &line);
if (ugh != NULL)
{
@ -274,8 +274,8 @@ static status_t pem_to_bin(chunk_t *blob, chunk_t(*cb)(void*,int), void *cb_data
}
else
{
DBG1(" encryption algorithm '%.*s' not supported",
dek.len, dek.ptr);
DBG1(DBG_LIB, " encryption algorithm '%.*s'"
" not supported", dek.len, dek.ptr);
return NOT_SUPPORTED;
}
eat_whitespace(&value);
@ -298,7 +298,8 @@ static status_t pem_to_bin(chunk_t *blob, chunk_t(*cb)(void*,int), void *cb_data
*pgp = TRUE;
data.ptr++;
data.len--;
DBG2(" armor checksum: %.*s", (int)data.len, data.ptr);
DBG2(DBG_LIB, " armor checksum: %.*s", (int)data.len,
data.ptr);
continue;
}
@ -318,7 +319,7 @@ static status_t pem_to_bin(chunk_t *blob, chunk_t(*cb)(void*,int), void *cb_data
if (state != PEM_POST)
{
DBG1(" file coded in unknown format, discarded");
DBG1(DBG_LIB, " file coded in unknown format, discarded");
return PARSE_ERROR;
}
if (!encrypted)
@ -327,7 +328,7 @@ static status_t pem_to_bin(chunk_t *blob, chunk_t(*cb)(void*,int), void *cb_data
}
if (!cb)
{
DBG1(" missing passphrase");
DBG1(DBG_LIB, " missing passphrase");
return INVALID_ARG;
}
while (TRUE)
@ -404,13 +405,14 @@ static void *load_from_file(char *file, credential_type_t type, int subtype,
fd = open(file, O_RDONLY);
if (fd == -1)
{
DBG1(" opening '%s' failed: %s", file, strerror(errno));
DBG1(DBG_LIB, " opening '%s' failed: %s", file, strerror(errno));
return NULL;
}
if (fstat(fd, &sb) == -1)
{
DBG1(" getting file size of '%s' failed: %s", file, strerror(errno));
DBG1(DBG_LIB, " getting file size of '%s' failed: %s", file,
strerror(errno));
close(fd);
return NULL;
}
@ -418,7 +420,7 @@ static void *load_from_file(char *file, credential_type_t type, int subtype,
addr = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (addr == MAP_FAILED)
{
DBG1(" mapping '%s' failed: %s", file, strerror(errno));
DBG1(DBG_LIB, " mapping '%s' failed: %s", file, strerror(errno));
close(fd);
return NULL;
}
@ -447,7 +449,8 @@ static void *load_from_fd(int fd, credential_type_t type, int subtype,
len = read(fd, pos, buf + sizeof(buf) - pos);
if (len < 0)
{
DBG1("reading from file descriptor failed: %s", strerror(errno));
DBG1(DBG_LIB, "reading from file descriptor failed: %s",
strerror(errno));
return NULL;
}
if (len == 0)
@ -457,7 +460,7 @@ static void *load_from_fd(int fd, credential_type_t type, int subtype,
total += len;
if (total == sizeof(buf))
{
DBG1("buffer too small to read from file descriptor");
DBG1(DBG_LIB, "buffer too small to read from file descriptor");
return NULL;
}
}

13
src/libstrongswan/plugins/pgp/pgp_builder.c
View File

@ -41,7 +41,7 @@ static public_key_t *parse_public_key(chunk_t blob)
BUILD_BLOB_PGP, blob, BUILD_END);
break;
default:
DBG1("PGP public key algorithm %N not supported",
DBG1(DBG_LIB, "PGP public key algorithm %N not supported",
pgp_pubkey_alg_names, alg);
return NULL;
}
@ -90,12 +90,13 @@ static private_key_t *parse_rsa_private_key(chunk_t blob)
}
if (s2k == 255 || s2k == 254)
{
DBG1("string-to-key specifiers not supported");
DBG1(DBG_LIB, "string-to-key specifiers not supported");
return NULL;
}
if (s2k != PGP_SYM_ALG_PLAIN)
{
DBG1("%N private key encryption not supported", pgp_sym_alg_names, s2k);
DBG1(DBG_LIB, "%N private key encryption not supported",
pgp_sym_alg_names, s2k);
return NULL;
}
@ -121,7 +122,7 @@ static private_key_t *parse_rsa_private_key(chunk_t blob)
static bool sign_not_allowed(private_key_t *this, signature_scheme_t scheme,
chunk_t data, chunk_t *signature)
{
DBG1("signing failed - decryption only key");
DBG1(DBG_LIB, "signing failed - decryption only key");
return FALSE;
}
@ -131,7 +132,7 @@ static bool sign_not_allowed(private_key_t *this, signature_scheme_t scheme,
static bool decrypt_not_allowed(private_key_t *this,
chunk_t crypto, chunk_t *plain)
{
DBG1("decryption failed - signature only key");
DBG1(DBG_LIB, "decryption failed - signature only key");
return FALSE;
}
@ -164,7 +165,7 @@ static private_key_t *parse_private_key(chunk_t blob)
case 4:
break;
default:
DBG1("PGP packet version V%d not supported", version);
DBG1(DBG_LIB, "PGP packet version V%d not supported", version);
return FALSE;
}
if (!pgp_read_scalar(&packet, 4, &created))

32
src/libstrongswan/plugins/pgp/pgp_cert.c
View File

@ -198,9 +198,9 @@ static bool is_newer(certificate_t *this, certificate_t *that)
this->get_validity(this, &now, &this_update, NULL);
that->get_validity(that, &now, &that_update, NULL);
new = this_update > that_update;
DBG1(" certificate from %T is %s - existing certificate from %T %s",
&this_update, FALSE, new ? "newer":"not newer",
&that_update, FALSE, new ? "replaced":"retained");
DBG1(DBG_LIB, " certificate from %T is %s - existing certificate"
" from %T %s", &this_update, FALSE, new ? "newer" : "not newer",
&that_update, FALSE, new ? "replaced" : "retained");
return new;
}
@ -322,16 +322,18 @@ static bool parse_public_key(private_pgp_cert_t *this, chunk_t packet)
}
break;
default:
DBG1("PGP packet version V%d not supported", this->version);
DBG1(DBG_LIB, "PGP packet version V%d not supported",
this->version);
return FALSE;
}
if (this->valid)
{
DBG2("L2 - created %T, valid %d days", &this->created, FALSE, this->valid);
DBG2(DBG_LIB, "L2 - created %T, valid %d days", &this->created, FALSE,
this->valid);
}
else
{
DBG2("L2 - created %T, never expires", &this->created, FALSE);
DBG2(DBG_LIB, "L2 - created %T, never expires", &this->created, FALSE);
}
DESTROY_IF(this->key);
this->key = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, KEY_ANY,
@ -352,13 +354,13 @@ static bool parse_public_key(private_pgp_cert_t *this, chunk_t packet)
hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
if (hasher == NULL)
{
DBG1("no SHA-1 hasher available");
DBG1(DBG_LIB, "no SHA-1 hasher available");
return FALSE;
}
hasher->allocate_hash(hasher, pubkey_packet_header, NULL);
hasher->allocate_hash(hasher, pubkey_packet, &this->fingerprint);
hasher->destroy(hasher);
DBG2("L2 - v4 fingerprint %#B", &this->fingerprint);
DBG2(DBG_LIB, "L2 - v4 fingerprint %#B", &this->fingerprint);
}
else
{
@ -369,7 +371,7 @@ static bool parse_public_key(private_pgp_cert_t *this, chunk_t packet)
return FALSE;
}
this->fingerprint = chunk_clone(this->fingerprint);
DBG2("L2 - v3 fingerprint %#B", &this->fingerprint);
DBG2(DBG_LIB, "L2 - v3 fingerprint %#B", &this->fingerprint);
}
return TRUE;
}
@ -389,7 +391,7 @@ static bool parse_signature(private_pgp_cert_t *this, chunk_t packet)
/* we parse only v3 or v4 signature packets */
if (version != 3 && version != 4)
{
DBG2("L2 - v%d signature ignored", version);
DBG2(DBG_LIB, "L2 - v%d signature ignored", version);
return TRUE;
}
if (version == 4)
@ -398,7 +400,7 @@ static bool parse_signature(private_pgp_cert_t *this, chunk_t packet)
{
return FALSE;
}
DBG2("L2 - v%d signature of type 0x%02x", version, type);
DBG2(DBG_LIB, "L2 - v%d signature of type 0x%02x", version, type);
}
else
{
@ -411,8 +413,8 @@ static bool parse_signature(private_pgp_cert_t *this, chunk_t packet)
{
return FALSE;
}
DBG2("L2 - v3 signature of type 0x%02x, created %T", type,
&created, FALSE);
DBG2(DBG_LIB, "L2 - v3 signature of type 0x%02x, created %T", type,
&created, FALSE);
}
/* TODO: parse and save signature to a list */
return TRUE;
@ -425,7 +427,7 @@ static bool parse_user_id(private_pgp_cert_t *this, chunk_t packet)
{
DESTROY_IF(this->user_id);
this->user_id = identification_create_from_encoding(ID_KEY_ID, packet);
DBG2("L2 - '%Y'", this->user_id);
DBG2(DBG_LIB, "L2 - '%Y'", this->user_id);
return TRUE;
}
@ -486,7 +488,7 @@ pgp_cert_t *pgp_cert_load(certificate_type_t type, va_list args)
}
break;
default:
DBG1("ignoring %N packet in PGP certificate",
DBG1(DBG_LIB, "ignoring %N packet in PGP certificate",
pgp_packet_tag_names, tag);
break;
}

3
src/libstrongswan/plugins/pgp/pgp_encoder.c
View File

@ -31,7 +31,8 @@ static bool build_v3_fingerprint(chunk_t *encoding, va_list args)
hasher = lib->crypto->create_hasher(lib->crypto, HASH_MD5);
if (!hasher)
{
DBG1("MD5 hash algorithm not supported, PGP fingerprinting failed");
DBG1(DBG_LIB, "MD5 hash algorithm not supported, PGP"
" fingerprinting failed");
return FALSE;
}
/* remove leading zero bytes before hashing modulus and exponent */

18
src/libstrongswan/plugins/pgp/pgp_utils.c
View File

@ -79,7 +79,7 @@ bool pgp_read_scalar(chunk_t *blob, size_t bytes, u_int32_t *scalar)
if (bytes > blob->len)
{
DBG1("PGP data too short to read %d byte scalar", bytes);
DBG1(DBG_LIB, "PGP data too short to read %d byte scalar", bytes);
return FALSE;
}
while (bytes-- > 0)
@ -100,13 +100,13 @@ bool pgp_read_mpi(chunk_t *blob, chunk_t *mpi)
if (!pgp_read_scalar(blob, 2, &bits))
{
DBG1("PGP data too short to read MPI length");
DBG1(DBG_LIB, "PGP data too short to read MPI length");
return FALSE;
}
bytes = (bits + 7) / 8;
if (bytes > blob->len)
{
DBG1("PGP data too short to read %d byte MPI", bytes);
DBG1(DBG_LIB, "PGP data too short to read %d byte MPI", bytes);
return FALSE;
}
*mpi = chunk_create(blob->ptr, bytes);
@ -146,7 +146,7 @@ bool pgp_read_packet(chunk_t *blob, chunk_t *data, pgp_packet_tag_t *tag)
if (!blob->len)
{
DBG1("missing input");
DBG1(DBG_LIB, "missing input");
return FALSE;
}
t = blob->ptr[0];
@ -154,27 +154,27 @@ bool pgp_read_packet(chunk_t *blob, chunk_t *data, pgp_packet_tag_t *tag)
/* bit 7 must be set */
if (!(t & 0x80))
{
DBG1("invalid packet tag");
DBG1(DBG_LIB, "invalid packet tag");
return FALSE;
}
/* bit 6 set defines new packet format */
if (t & 0x40)
{
DBG1("new PGP packet format not supported");
DBG1(DBG_LIB, "new PGP packet format not supported");
return FALSE;
}
t = (t & 0x3C) >> 2;
if (!pgp_old_packet_length(blob, &len) || len > blob->len)
{
DBG1("invalid packet length");
DBG1(DBG_LIB, "invalid packet length");
return FALSE;
}
*data = chunk_create(blob->ptr, len);
*blob = chunk_skip(*blob, len);
*tag = t;
DBG2("L1 - PGP %N (%u bytes)", pgp_packet_tag_names, t, len);
DBG3("%B", data);
DBG2(DBG_LIB, "L1 - PGP %N (%u bytes)", pgp_packet_tag_names, t, len);
DBG3(DBG_LIB, "%B", data);
return TRUE;
}

6
src/libstrongswan/plugins/pkcs1/pkcs1_builder.c
View File

@ -81,10 +81,10 @@ static public_key_t *parse_public_key(chunk_t blob)
/* skip initial bit string octet defining 0 unused bits */
object = chunk_skip(object, 1);
}
DBG2("-- > --");
DBG2(DBG_LIB, "-- > --");
key = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, type,
BUILD_BLOB_ASN1_DER, object, BUILD_END);
DBG2("-- < --");
DBG2(DBG_LIB, "-- < --");
break;
}
}
@ -197,7 +197,7 @@ static private_key_t *parse_rsa_private_key(chunk_t blob)
case PRIV_KEY_VERSION:
if (object.len > 0 && *object.ptr != 0)
{
DBG1("PKCS#1 private key format is not version 1");
DBG1(DBG_LIB, "PKCS#1 private key format is not version 1");
goto end;
}
break;

3
src/libstrongswan/plugins/pkcs1/pkcs1_encoder.c
View File

@ -97,7 +97,8 @@ static bool hash_pubkey(chunk_t pubkey, chunk_t *hash)
if (hasher == NULL)
{
chunk_free(&pubkey);
DBG1("SHA1 hash algorithm not supported, fingerprinting failed");
DBG1(DBG_LIB, "SHA1 hash algorithm not supported, "
"fingerprinting failed");
return FALSE;
}
hasher->allocate_hash(hasher, pubkey, hash);

29
src/libstrongswan/plugins/plugin_loader.c
View File

@ -70,16 +70,18 @@ static plugin_t* load_plugin(private_plugin_loader_t *this,
constructor = dlsym(RTLD_DEFAULT, create);
if (constructor == NULL)
{
DBG1("plugin '%s': failed to load - %s not found", name, create);
DBG1(DBG_LIB, "plugin '%s': failed to load - %s not found", name,
create);
return NULL;
}
plugin = constructor();
if (plugin == NULL)
{
DBG1("plugin '%s': failed to load - %s returned NULL", name, create);
DBG1(DBG_LIB, "plugin '%s': failed to load - %s returned NULL", name,
create);
return NULL;
}
DBG2("plugin '%s': loaded successfully", name);
DBG2(DBG_LIB, "plugin '%s': loaded successfully", name);
return plugin;
}
@ -108,20 +110,23 @@ static plugin_t* load_plugin(private_plugin_loader_t *this,
{
if (!lib->integrity->check_file(lib->integrity, name, file))
{
DBG1("plugin '%s': failed file integrity test of '%s'", name, file);
DBG1(DBG_LIB, "plugin '%s': failed file integrity test of '%s'",
name, file);
return NULL;
}
}
handle = dlopen(file, RTLD_LAZY);
if (handle == NULL)
{
DBG1("plugin '%s': failed to load '%s' - %s", name, file, dlerror());
DBG1(DBG_LIB, "plugin '%s': failed to load '%s' - %s", name, file,
dlerror());
return NULL;
}
constructor = dlsym(handle, create);
if (constructor == NULL)
{
DBG1("plugin '%s': failed to load - %s not found", name, create);
DBG1(DBG_LIB, "plugin '%s': failed to load - %s not found", name,
create);
dlclose(handle);
return NULL;
}
@ -129,20 +134,22 @@ static plugin_t* load_plugin(private_plugin_loader_t *this,
{
if (!lib->integrity->check_segment(lib->integrity, name, constructor))
{
DBG1("plugin '%s': failed segment integrity test", name);
DBG1(DBG_LIB, "plugin '%s': failed segment integrity test", name);
dlclose(handle);
return NULL;
}
DBG1("plugin '%s': passed file and segment integrity tests", name);
DBG1(DBG_LIB, "plugin '%s': passed file and segment integrity tests",
name);
}
plugin = constructor();
if (plugin == NULL)
{
DBG1("plugin '%s': failed to load - %s returned NULL", name, create);
DBG1(DBG_LIB, "plugin '%s': failed to load - %s returned NULL", name,
create);
dlclose(handle);
return NULL;
}
DBG2("plugin '%s': loaded successfully", name);
DBG2(DBG_LIB, "plugin '%s': loaded successfully", name);
/* we do not store or free dlopen() handles, leak_detective requires
* the modules to keep loaded until leak report */
@ -192,7 +199,7 @@ static bool load(private_plugin_loader_t *this, char *path, char *list)
if (critical)
{
critical_failed = TRUE;
DBG1("loading critical plugin '%s' failed", token);
DBG1(DBG_LIB, "loading critical plugin '%s' failed", token);
}
free(token);
}

4
src/libstrongswan/plugins/random/random_rng.c
View File

@ -71,7 +71,7 @@ static void get_bytes(private_random_rng_t *this, size_t bytes,
got = read(this->dev, buffer + done, bytes - done);
if (got <= 0)
{
DBG1("reading from \"%s\" failed: %s, retrying...",
DBG1(DBG_LIB, "reading from \"%s\" failed: %s, retrying...",
this->file, strerror(errno));
close(this->dev);
sleep(1);
@ -124,7 +124,7 @@ random_rng_t *random_rng_create(rng_quality_t quality)
this->dev = open(this->file, 0);
if (this->dev < 0)
{
DBG1("opening \"%s\" failed: %s", this->file, strerror(errno));
DBG1(DBG_LIB, "opening \"%s\" failed: %s", this->file, strerror(errno));
free(this);
return NULL;
}

15
src/libstrongswan/plugins/sqlite/sqlite_database.c
View File

@ -110,11 +110,13 @@ static sqlite3_stmt* run(private_sqlite_database_t *this, char *sql,
}
else
{
DBG1("preparing sqlite statement failed: %s", sqlite3_errmsg(this->db));
DBG1(DBG_LIB, "preparing sqlite statement failed: %s",
sqlite3_errmsg(this->db));
}
if (res != SQLITE_OK)
{
DBG1("binding sqlite statement failed: %s", sqlite3_errmsg(this->db));
DBG1(DBG_LIB, "binding sqlite statement failed: %s",
sqlite3_errmsg(this->db));
sqlite3_finalize(stmt);
return NULL;
}
@ -160,7 +162,7 @@ static bool sqlite_enumerator_enumerate(sqlite_enumerator_t *this, ...)
case SQLITE_ROW:
break;
default:
DBG1("stepping sqlite statement failed: %s",
DBG1(DBG_LIB, "stepping sqlite statement failed: %s",
sqlite3_errmsg(this->database->db));
/* fall */
case SQLITE_DONE:
@ -203,7 +205,7 @@ static bool sqlite_enumerator_enumerate(sqlite_enumerator_t *this, ...)
break;
}
default:
DBG1("invalid result type supplied");
DBG1(DBG_LIB, "invalid result type supplied");
return FALSE;
}
}
@ -272,7 +274,8 @@ static int execute(private_sqlite_database_t *this, int *rowid, char *sql, ...)
}
else
{
DBG1("sqlite execute failed: %s", sqlite3_errmsg(this->db));
DBG1(DBG_LIB, "sqlite execute failed: %s",
sqlite3_errmsg(this->db));
}
sqlite3_finalize(stmt);
}
@ -337,7 +340,7 @@ sqlite_database_t *sqlite_database_create(char *uri)
if (sqlite3_open(file, &this->db) != SQLITE_OK)
{
DBG1("opening SQLite database '%s' failed: %s",
DBG1(DBG_LIB, "opening SQLite database '%s' failed: %s",
file, sqlite3_errmsg(this->db));
destroy(this);
return NULL;

6
src/libstrongswan/plugins/test_vectors/test_vectors/rng.c
View File

@ -44,7 +44,7 @@ static bool test_monobit(monobit_t *param, chunk_t data)
}
}
}
DBG2(" Monobit: %d/%d bits set", bits, data.len * 8);
DBG2(DBG_LIB, " Monobit: %d/%d bits set", bits, data.len * 8);
if (bits > param->lower && bits < param->upper)
{
return TRUE;
@ -101,7 +101,7 @@ static bool test_poker(poker_t *param, chunk_t data)
sum += (counter[i] * counter[i]) / 5000.0 * 16.0;
}
sum -= 5000.0;
DBG2(" Poker: %f", sum);
DBG2(DBG_LIB, " Poker: %f", sum);
if (sum > param->lower && sum < param->upper)
{
return TRUE;
@ -190,7 +190,7 @@ static bool test_runs(runs_t *param, chunk_t data)
}
}
DBG2(" Runs: zero: %d/%d/%d/%d/%d/%d, one: %d/%d/%d/%d/%d/%d, "
DBG2(DBG_LIB, " Runs: zero: %d/%d/%d/%d/%d/%d, one: %d/%d/%d/%d/%d/%d, "
"longruns: %d",
zero_runs[1], zero_runs[2], zero_runs[3],
zero_runs[4], zero_runs[5], zero_runs[6],

35
src/libstrongswan/plugins/x509/x509_ac.c
View File

@ -192,7 +192,7 @@ static bool parse_directoryName(chunk_t blob, int level, bool implicit, identifi
}
else
{
DBG1("more than one directory name - first selected");
DBG1(DBG_LIB, "more than one directory name - first selected");
directoryName->destroy(directoryName);
}
}
@ -200,7 +200,7 @@ static bool parse_directoryName(chunk_t blob, int level, bool implicit, identifi
}
else
{
DBG1("no directoryName found");
DBG1(DBG_LIB, "no directoryName found");
}
list->destroy(list);
@ -359,10 +359,11 @@ static bool parse_certificate(private_x509_ac_t *this)
break;
case AC_OBJ_VERSION:
this->version = (object.len) ? (1 + (u_int)*object.ptr) : 1;
DBG2(" v%d", this->version);
DBG2(DBG_LIB, " v%d", this->version);
if (this->version != 2)
{
DBG1("v%d attribute certificates are not supported", this->version);
DBG1(DBG_LIB, "v%d attribute certificates are not "
"supported", this->version);
goto end;
}
break;
@ -407,20 +408,20 @@ static bool parse_certificate(private_x509_ac_t *this)
switch (type)
{
case OID_AUTHENTICATION_INFO:
DBG2(" need to parse authenticationInfo");
DBG2(DBG_LIB, " need to parse authenticationInfo");
break;
case OID_ACCESS_IDENTITY:
DBG2(" need to parse accessIdentity");
DBG2(DBG_LIB, " need to parse accessIdentity");
break;
case OID_CHARGING_IDENTITY:
DBG2("-- > --");
DBG2(DBG_LIB, "-- > --");
this->charging = ietf_attributes_create_from_encoding(object);
DBG2("-- < --");
DBG2(DBG_LIB, "-- < --");
break;
case OID_GROUP:
DBG2("-- > --");
DBG2(DBG_LIB, "-- > --");
this->groups = ietf_attributes_create_from_encoding(object);
DBG2("-- < --");
DBG2(DBG_LIB, "-- < --");
break;
case OID_ROLE:
parse_roleSyntax(object, level);
@ -435,21 +436,21 @@ static bool parse_certificate(private_x509_ac_t *this)
break;
case AC_OBJ_CRITICAL:
critical = object.len && *object.ptr;
DBG2(" %s",(critical)?"TRUE":"FALSE");
DBG2(DBG_LIB, " %s",(critical)?"TRUE":"FALSE");
break;
case AC_OBJ_EXTN_VALUE:
{
switch (extn_oid)
{
case OID_CRL_DISTRIBUTION_POINTS:
DBG2(" need to parse crlDistributionPoints");
DBG2(DBG_LIB, " need to parse crlDistributionPoints");
break;
case OID_AUTHORITY_KEY_ID:
this->authKeyIdentifier = x509_parse_authorityKeyIdentifier(object,
level, &this->authKeySerialNumber);
break;
case OID_TARGET_INFORMATION:
DBG2(" need to parse targetInformation");
DBG2(DBG_LIB, " need to parse targetInformation");
break;
case OID_NO_REV_AVAIL:
this->noRevAvail = TRUE;
@ -464,7 +465,7 @@ static bool parse_certificate(private_x509_ac_t *this)
NULL);
if (this->algorithm != sig_alg)
{
DBG1(" signature algorithms do not agree");
DBG1(DBG_LIB, " signature algorithms do not agree");
success = FALSE;
goto end;
}
@ -824,9 +825,9 @@ static bool is_newer(private_x509_ac_t *this, ac_t *that)
this_cert->get_validity(this_cert, &now, &this_update, NULL);
that_cert->get_validity(that_cert, &now, &that_update, NULL);
new = this_update > that_update;
DBG1(" attr cert from %T is %s - existing attr cert from %T %s",
&this_update, FALSE, new ? "newer":"not newer",
&that_update, FALSE, new ? "replaced":"retained");
DBG1(DBG_LIB, " attr cert from %T is %s - existing attr cert from %T %s",
&this_update, FALSE, new ? "newer":"not newer",
&that_update, FALSE, new ? "replaced":"retained");
return new;
}

58
src/libstrongswan/plugins/x509/x509_cert.c
View File

@ -219,7 +219,7 @@ static void parse_basicConstraints(chunk_t blob, int level0,
{
case BASIC_CONSTRAINTS_CA:
isCA = object.len && *object.ptr;
DBG2(" %s", isCA ? "TRUE" : "FALSE");
DBG2(DBG_LIB, " %s", isCA ? "TRUE" : "FALSE");
if (isCA)
{
this->flags |= X509_CA;
@ -383,7 +383,7 @@ static identification_t *parse_generalName(chunk_t blob, int level0)
if (id_type != ID_ANY)
{
gn = identification_create_from_encoding(id_type, object);
DBG2(" '%Y'", gn);
DBG2(DBG_LIB, " '%Y'", gn);
goto end;
}
}
@ -539,7 +539,7 @@ static void parse_authorityInfoAccess(chunk_t blob, int level0,
/* parsing went wrong - abort */
goto end;
}
DBG2(" '%Y'", id);
DBG2(DBG_LIB, " '%Y'", id);
if (accessMethod == OID_OCSP &&
asprintf(&uri, "%Y", id) > 0)
{
@ -704,34 +704,36 @@ static bool check_address_object(ts_type_t ts_type, chunk_t object)
case TS_IPV4_ADDR_RANGE:
if (object.len > 5)
{
DBG1("IPv4 address object is larger than 5 octets");
DBG1(DBG_LIB, "IPv4 address object is larger than 5 octets");
return FALSE;
}
break;
case TS_IPV6_ADDR_RANGE:
if (object.len > 17)
{
DBG1("IPv6 address object is larger than 17 octets");
DBG1(DBG_LIB, "IPv6 address object is larger than 17 octets");
return FALSE;
}
break;
default:
DBG1("unknown address family");
DBG1(DBG_LIB, "unknown address family");
return FALSE;
}
if (object.len == 0)
{
DBG1("An ASN.1 bit string must contain at least the initial octet");
DBG1(DBG_LIB, "An ASN.1 bit string must contain at least the "
"initial octet");
return FALSE;
}
if (object.len == 1 && object.ptr[0] != 0)
{
DBG1("An empty ASN.1 bit string must contain a zero initial octet");
DBG1(DBG_LIB, "An empty ASN.1 bit string must contain a zero "
"initial octet");
return FALSE;
}
if (object.ptr[0] > 7)
{
DBG1("number of unused bits is too large");
DBG1(DBG_LIB, "number of unused bits is too large");
return FALSE;
}
return TRUE;
@ -769,11 +771,11 @@ static void parse_ipAddrBlocks(chunk_t blob, int level0,
{
break;
}
DBG2(" %N", ts_type_name, ts_type);
DBG2(DBG_LIB, " %N", ts_type_name, ts_type);
}
break;
case IP_ADDR_BLOCKS_INHERIT:
DBG1("inherit choice is not supported");
DBG1(DBG_LIB, "inherit choice is not supported");
break;
case IP_ADDR_BLOCKS_PREFIX:
if (!check_address_object(ts_type, object))
@ -782,7 +784,7 @@ static void parse_ipAddrBlocks(chunk_t blob, int level0,
}
ts = traffic_selector_create_from_rfc3779_format(ts_type,
object, object);
DBG2(" %R", ts);
DBG2(DBG_LIB, " %R", ts);
this->ipAddrBlocks->insert_last(this->ipAddrBlocks, ts);
break;
case IP_ADDR_BLOCKS_MIN:
@ -799,7 +801,7 @@ static void parse_ipAddrBlocks(chunk_t blob, int level0,
}
ts = traffic_selector_create_from_rfc3779_format(ts_type,
min_object, object);
DBG2(" %R", ts);
DBG2(DBG_LIB, " %R", ts);
this->ipAddrBlocks->insert_last(this->ipAddrBlocks, ts);
break;
default:
@ -893,12 +895,12 @@ static bool parse_certificate(private_x509_cert_t *this)
this->version = (object.len) ? (1+(u_int)*object.ptr) : 1;
if (this->version < 1 || this->version > 3)
{
DBG1("X.509v%d not supported", this->version);
DBG1(DBG_LIB, "X.509v%d not supported", this->version);
goto end;
}
else
{
DBG2(" X.509v%d", this->version);
DBG2(DBG_LIB, " X.509v%d", this->version);
}
break;
case X509_OBJ_SERIAL_NUMBER:
@ -909,7 +911,7 @@ static bool parse_certificate(private_x509_cert_t *this)
break;
case X509_OBJ_ISSUER:
this->issuer = identification_create_from_encoding(ID_DER_ASN1_DN, object);
DBG2(" '%Y'", this->issuer);
DBG2(DBG_LIB, " '%Y'", this->issuer);
break;
case X509_OBJ_NOT_BEFORE:
this->notBefore = asn1_parse_time(object, level);
@ -919,13 +921,13 @@ static bool parse_certificate(private_x509_cert_t *this)
break;
case X509_OBJ_SUBJECT:
this->subject = identification_create_from_encoding(ID_DER_ASN1_DN, object);
DBG2(" '%Y'", this->subject);
DBG2(DBG_LIB, " '%Y'", this->subject);
break;
case X509_OBJ_SUBJECT_PUBLIC_KEY_INFO:
DBG2("-- > --");
DBG2(DBG_LIB, "-- > --");
this->public_key = lib->creds->create(lib->creds, CRED_PUBLIC_KEY,
KEY_ANY, BUILD_BLOB_ASN1_DER, object, BUILD_END);
DBG2("-- < --");
DBG2(DBG_LIB, "-- < --");
if (this->public_key == NULL)
{
goto end;
@ -934,7 +936,7 @@ static bool parse_certificate(private_x509_cert_t *this)
case X509_OBJ_OPTIONAL_EXTENSIONS:
if (this->version != 3)
{
DBG1("Only X.509v3 certificates have extensions");
DBG1(DBG_LIB, "Only X.509v3 certificates have extensions");
goto end;
}
break;
@ -943,7 +945,7 @@ static bool parse_certificate(private_x509_cert_t *this)
break;
case X509_OBJ_CRITICAL:
critical = object.len && *object.ptr;
DBG2(" %s", critical ? "TRUE" : "FALSE");
DBG2(DBG_LIB, " %s", critical ? "TRUE" : "FALSE");
break;
case X509_OBJ_EXTN_VALUE:
{
@ -997,7 +999,7 @@ static bool parse_certificate(private_x509_cert_t *this)
if (critical && lib->settings->get_bool(lib->settings,
"libstrongswan.plugins.x509.enforce_critical", FALSE))
{
DBG1("critical %s extension not supported",
DBG1(DBG_LIB, "critical %s extension not supported",
(extn_oid == OID_UNKNOWN) ? "unknown" :
(char*)oid_names[extn_oid].name);
goto end;
@ -1010,7 +1012,7 @@ static bool parse_certificate(private_x509_cert_t *this)
this->algorithm = asn1_parse_algorithmIdentifier(object, level, NULL);
if (this->algorithm != sig_alg)
{
DBG1(" signature algorithms do not agree");
DBG1(DBG_LIB, " signature algorithms do not agree");
goto end;
}
break;
@ -1038,7 +1040,7 @@ end:
hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
if (hasher == NULL)
{
DBG1(" unable to create hash of certificate, SHA1 not supported");
DBG1(DBG_LIB, " unable to create hash of certificate, SHA1 not supported");
return NULL;
}
hasher->allocate_hash(hasher, this->encoding, &this->encoding_hash);
@ -1217,9 +1219,9 @@ static bool is_newer(certificate_t *this, certificate_t *that)
this->get_validity(this, &now, &this_update, NULL);
that->get_validity(that, &now, &that_update, NULL);
new = this_update > that_update;
DBG1(" certificate from %T is %s - existing certificate from %T %s",
&this_update, FALSE, new ? "newer":"not newer",
&that_update, FALSE, new ? "replaced":"retained");
DBG1(DBG_LIB, " certificate from %T is %s - existing certificate "
"from %T %s", &this_update, FALSE, new ? "newer":"not newer",
&that_update, FALSE, new ? "replaced":"retained");
return new;
}
@ -1456,7 +1458,7 @@ chunk_t x509_build_subjectAltNames(linked_list_t *list)
context = ASN1_CONTEXT_S_7;
break;
default:
DBG1("encoding %N as subjectAltName not supported",
DBG1(DBG_LIB, "encoding %N as subjectAltName not supported",
id_type_names, id->get_type(id));
enumerator->destroy(enumerator);
free(subjectAltNames.ptr);

15
src/libstrongswan/plugins/x509/x509_crl.c
View File

@ -216,14 +216,14 @@ static bool parse(private_x509_crl_t *this)
break;
case CRL_OBJ_VERSION:
this->version = (object.len) ? (1+(u_int)*object.ptr) : 1;
DBG2(" v%d", this->version);
DBG2(DBG_LIB, " v%d", this->version);
break;
case CRL_OBJ_SIG_ALG:
sig_alg = asn1_parse_algorithmIdentifier(object, level, NULL);
break;
case CRL_OBJ_ISSUER:
this->issuer = identification_create_from_encoding(ID_DER_ASN1_DN, object);
DBG2(" '%Y'", this->issuer);
DBG2(DBG_LIB, " '%Y'", this->issuer);
break;
case CRL_OBJ_THIS_UPDATE:
this->thisUpdate = asn1_parse_time(object, level);
@ -248,7 +248,7 @@ static bool parse(private_x509_crl_t *this)
case CRL_OBJ_CRL_ENTRY_CRITICAL:
case CRL_OBJ_CRITICAL:
critical = object.len && *object.ptr;
DBG2(" %s", critical ? "TRUE" : "FALSE");
DBG2(DBG_LIB, " %s", critical ? "TRUE" : "FALSE");
break;
case CRL_OBJ_CRL_ENTRY_EXTN_VALUE:
case CRL_OBJ_EXTN_VALUE:
@ -262,7 +262,8 @@ static bool parse(private_x509_crl_t *this)
{
revoked->reason = *object.ptr;
}
DBG2(" '%N'", crl_reason_names, revoked->reason);
DBG2(DBG_LIB, " '%N'", crl_reason_names,
revoked->reason);
}
else if (extn_oid == OID_AUTHORITY_KEY_ID)
{
@ -286,7 +287,7 @@ static bool parse(private_x509_crl_t *this)
this->algorithm = asn1_parse_algorithmIdentifier(object, level, NULL);
if (this->algorithm != sig_alg)
{
DBG1(" signature algorithms do not agree");
DBG1(DBG_LIB, " signature algorithms do not agree");
goto end;
}
break;
@ -483,7 +484,7 @@ static bool is_newer(private_x509_crl_t *this, crl_t *that)
if (this->crlNumber.ptr != NULL && that_crlNumber.ptr != NULL)
{
new = chunk_compare(this->crlNumber, that_crlNumber) > 0;
DBG1(" crl #%#B is %s - existing crl #%#B %s",
DBG1(DBG_LIB, " crl #%#B is %s - existing crl #%#B %s",
&this->crlNumber, new ? "newer":"not newer",
&that_crlNumber, new ? "replaced":"retained");
}
@ -497,7 +498,7 @@ static bool is_newer(private_x509_crl_t *this, crl_t *that)
this_cert->get_validity(this_cert, &now, &this_update, NULL);
that_cert->get_validity(that_cert, &now, &that_update, NULL);
new = this_update > that_update;
DBG1(" crl from %T is %s - existing crl from %T %s",
DBG1(DBG_LIB, " crl from %T is %s - existing crl from %T %s",
&this_update, FALSE, new ? "newer":"not newer",
&that_update, FALSE, new ? "replaced":"retained");
}

15
src/libstrongswan/plugins/x509/x509_ocsp_request.c
View File

@ -179,13 +179,14 @@ static chunk_t build_requestList(private_x509_ocsp_request_t *this)
}
else
{
DBG1("creating OCSP request failed, SHA1 not supported");
DBG1(DBG_LIB, "creating OCSP request failed, SHA1 not supported");
}
public->destroy(public);
}
else
{
DBG1("creating OCSP request failed, CA certificate has no public key");
DBG1(DBG_LIB, "creating OCSP request failed, CA certificate has "
"no public key");
}
return asn1_wrap(ASN1_SEQUENCE, "m", list);
}
@ -205,7 +206,7 @@ static chunk_t build_nonce(private_x509_ocsp_request_t *this)
return asn1_wrap(ASN1_SEQUENCE, "cm", ASN1_nonce_oid,
asn1_simple_object(ASN1_OCTET_STRING, this->nonce));
}
DBG1("creating OCSP request nonce failed, no RNG found");
DBG1(DBG_LIB, "creating OCSP request nonce failed, no RNG found");
return chunk_empty;
}
@ -263,14 +264,14 @@ static chunk_t build_optionalSignature(private_x509_ocsp_request_t *this,
scheme = SIGN_ECDSA_WITH_SHA1_DER;
break;
default:
DBG1("unable to sign OCSP request, %N signature not supported",
key_type_names, this->key->get_type(this->key));
DBG1(DBG_LIB, "unable to sign OCSP request, %N signature not "
"supported", key_type_names, this->key->get_type(this->key));
return chunk_empty;
}
if (!this->key->sign(this->key, scheme, tbsRequest, &signature))
{
DBG1("creating OCSP signature failed, skipped");
DBG1(DBG_LIB, "creating OCSP signature failed, skipped");
return chunk_empty;
}
if (this->cert)
@ -378,7 +379,7 @@ static id_match_t has_issuer(private_x509_ocsp_request_t *this,
*/
static bool issued_by(private_x509_ocsp_request_t *this, certificate_t *issuer)
{
DBG1("OCSP request validation not implemented!");
DBG1(DBG_LIB, "OCSP request validation not implemented!");
return FALSE;
}

20
src/libstrongswan/plugins/x509/x509_ocsp_response.c
View File

@ -509,7 +509,8 @@ static bool parse_basicOCSPResponse(private_x509_ocsp_response_t *this,
if (version != OCSP_BASIC_RESPONSE_VERSION)
{
DBG1(" ocsp ResponseData version %d not supported", version);
DBG1(DBG_LIB, " ocsp ResponseData version %d not "
"supported", version);
goto end;
}
break;
@ -517,12 +518,12 @@ static bool parse_basicOCSPResponse(private_x509_ocsp_response_t *this,
case BASIC_RESPONSE_ID_BY_NAME:
this->responderId = identification_create_from_encoding(
ID_DER_ASN1_DN, object);
DBG2(" '%Y'", this->responderId);
DBG2(DBG_LIB, " '%Y'", this->responderId);
break;
case BASIC_RESPONSE_ID_BY_KEY:
this->responderId = identification_create_from_encoding(
ID_KEY_ID, object);
DBG2(" '%Y'", this->responderId);
DBG2(DBG_LIB, " '%Y'", this->responderId);
break;
case BASIC_RESPONSE_PRODUCED_AT:
this->producedAt = asn1_to_time(&object, ASN1_GENERALIZEDTIME);
@ -536,7 +537,7 @@ static bool parse_basicOCSPResponse(private_x509_ocsp_response_t *this,
break;
case BASIC_RESPONSE_CRITICAL:
critical = object.len && *object.ptr;
DBG2(" %s", critical ? "TRUE" : "FALSE");
DBG2(DBG_LIB, " %s", critical ? "TRUE" : "FALSE");
break;
case BASIC_RESPONSE_EXT_VALUE:
if (extn_oid == OID_NONCE)
@ -622,7 +623,7 @@ static bool parse_OCSPResponse(private_x509_ocsp_response_t *this)
case OCSP_SUCCESSFUL:
break;
default:
DBG1(" ocsp response status: %N",
DBG1(DBG_LIB, " ocsp response status: %N",
ocsp_status_names, status);
goto end;
}
@ -638,7 +639,8 @@ static bool parse_OCSPResponse(private_x509_ocsp_response_t *this)
parser->get_level(parser)+1);
break;
default:
DBG1(" ocsp response type %#B not supported", &object);
DBG1(DBG_LIB, " ocsp response type %#B not supported",
&object);
goto end;
}
break;
@ -772,9 +774,9 @@ static bool is_newer(certificate_t *this, certificate_t *that)
this->get_validity(this, &now, &this_update, NULL);
that->get_validity(that, &now, &that_update, NULL);
new = this_update > that_update;
DBG1(" ocsp response from %T is %s - existing ocsp response from %T %s",
&this_update, FALSE, new ? "newer":"not newer",
&that_update, FALSE, new ? "replaced":"retained");
DBG1(DBG_LIB, " ocsp response from %T is %s - existing ocsp response "
"from %T %s", &this_update, FALSE, new ? "newer" : "not newer",
&that_update, FALSE, new ? "replaced" : "retained");
return new;
}

27
src/libstrongswan/plugins/x509/x509_pkcs10.c
View File

@ -297,7 +297,7 @@ static bool parse_extension_request(private_x509_pkcs10_t *this, chunk_t blob, i
break;
case PKCS10_EXTN_CRITICAL:
critical = object.len && *object.ptr;
DBG2(" %s", critical ? "TRUE" : "FALSE");
DBG2(DBG_LIB, " %s", critical ? "TRUE" : "FALSE");
break;
case PKCS10_EXTN_VALUE:
{
@ -330,25 +330,25 @@ static bool parse_challengePassword(private_x509_pkcs10_t *this, chunk_t blob, i
if (blob.len < 2)
{
DBG1("L%d - challengePassword: ASN.1 object smaller than 2 octets",
level);
DBG1(DBG_LIB, "L%d - challengePassword: ASN.1 object smaller "
"than 2 octets", level);
return FALSE;
}
tag = *blob.ptr;
if (tag < ASN1_UTF8STRING || tag > ASN1_IA5STRING)
{
DBG1("L%d - challengePassword: ASN.1 object is not a character string",
level);
DBG1(DBG_LIB, "L%d - challengePassword: ASN.1 object is not "
"a character string", level);
return FALSE;
}
if (asn1_length(&blob) == ASN1_INVALID_LENGTH)
{
DBG1("L%d - challengePassword: ASN.1 object has an invalid length",
level);
DBG1(DBG_LIB, "L%d - challengePassword: ASN.1 object has an "
"invalid length", level);
return FALSE;
}
DBG2("L%d - challengePassword:", level);
DBG4(" '%.*s'", blob.len, blob.ptr);
}
DBG2(DBG_LIB, "L%d - challengePassword:", level);
DBG4(DBG_LIB, " '%.*s'", blob.len, blob.ptr);
return TRUE;
}
@ -406,13 +406,14 @@ static bool parse_certificate_request(private_x509_pkcs10_t *this)
case PKCS10_VERSION:
if (object.len > 0 && *object.ptr != 0)
{
DBG1("PKCS#10 certificate request format is not version 1");
DBG1(DBG_LIB, "PKCS#10 certificate request format is "
"not version 1");
goto end;
}
break;
case PKCS10_SUBJECT:
this->subject = identification_create_from_encoding(ID_DER_ASN1_DN, object);
DBG2(" '%Y'", this->subject);
DBG2(DBG_LIB, " '%Y'", this->subject);
break;
case PKCS10_SUBJECT_PUBLIC_KEY_INFO:
this->public_key = lib->creds->create(lib->creds, CRED_PUBLIC_KEY,
@ -467,7 +468,7 @@ end:
}
else
{
DBG1("certificate request is not self-signed");
DBG1(DBG_LIB, "certificate request is not self-signed");
success = FALSE;
}
}

8
src/libstrongswan/printf_hook.c
View File

@ -333,7 +333,8 @@ static void add_handler(private_printf_hook_t *this, char spec,
if (!IS_VALID_SPEC(spec))
{
DBG1("'%c' is not a valid printf hook specifier, not registered!", spec);
DBG1(DBG_LIB, "'%c' is not a valid printf hook specifier, "
"not registered!", spec);
return;
}
@ -345,7 +346,8 @@ static void add_handler(private_printf_hook_t *this, char spec,
{
if (++i >= ARGS_MAX)
{
DBG1("Too many arguments for printf hook with specifier '%c', not registered!", spec);
DBG1(DBG_LIB, "Too many arguments for printf hook with "
"specifier '%c', not registered!", spec);
va_end(args);
free(handler);
return;
@ -427,7 +429,7 @@ printf_hook_t *printf_hook_create()
#ifdef USE_VSTR
if (!vstr_init())
{
DBG1("failed to initialize Vstr library!");
DBG1(DBG_LIB, "failed to initialize Vstr library!");
free(this);
return NULL;
}

6
src/libstrongswan/settings.c
View File

@ -497,7 +497,7 @@ static section_t* parse_section(char **text, char *name)
continue;
}
}
DBG1("matching '}' not found near %s", *text);
DBG1(DBG_LIB, "matching '}' not found near %s", *text);
break;
case '=':
if (parse(text, "\t ", "\n", NULL, &value))
@ -508,7 +508,7 @@ static section_t* parse_section(char **text, char *name)
section->kv->insert_last(section->kv, kv);
continue;
}
DBG1("parsing value failed near %s", *text);
DBG1(DBG_LIB, "parsing value failed near %s", *text);
break;
case '#':
parse(text, "", "\n", NULL, &value);
@ -566,7 +566,7 @@ settings_t *settings_create(char *file)
fd = fopen(file, "r");
if (fd == NULL)
{
DBG1("'%s' does not exist or is not readable", file);
DBG1(DBG_LIB, "'%s' does not exist or is not readable", file);
return &this->public;
}
fseek(fd, 0, SEEK_END);

4
src/libstrongswan/threading/mutex.c
View File

@ -108,7 +108,7 @@ static void lock(private_mutex_t *this)
err = pthread_mutex_lock(&this->mutex);
if (err)
{
DBG1("!!! MUTEX LOCK ERROR: %s !!!", strerror(err));
DBG1(DBG_LIB, "!!! MUTEX LOCK ERROR: %s !!!", strerror(err));
}
profiler_end(&this->profile);
}
@ -123,7 +123,7 @@ static void unlock(private_mutex_t *this)
err = pthread_mutex_unlock(&this->mutex);
if (err)
{
DBG1("!!! MUTEX UNLOCK ERROR: %s !!!", strerror(err));
DBG1(DBG_LIB, "!!! MUTEX UNLOCK ERROR: %s !!!", strerror(err));
}
}

6
src/libstrongswan/threading/rwlock.c
View File

@ -98,7 +98,7 @@ static void read_lock(private_rwlock_t *this)
err = pthread_rwlock_rdlock(&this->rwlock);
if (err != 0)
{
DBG1("!!! RWLOCK READ LOCK ERROR: %s !!!", strerror(err));
DBG1(DBG_LIB, "!!! RWLOCK READ LOCK ERROR: %s !!!", strerror(err));
}
profiler_end(&this->profile);
}
@ -114,7 +114,7 @@ static void write_lock(private_rwlock_t *this)
err = pthread_rwlock_wrlock(&this->rwlock);
if (err != 0)
{
DBG1("!!! RWLOCK WRITE LOCK ERROR: %s !!!", strerror(err));
DBG1(DBG_LIB, "!!! RWLOCK WRITE LOCK ERROR: %s !!!", strerror(err));
}
profiler_end(&this->profile);
}
@ -137,7 +137,7 @@ static void rw_unlock(private_rwlock_t *this)
err = pthread_rwlock_unlock(&this->rwlock);
if (err != 0)
{
DBG1("!!! RWLOCK UNLOCK ERROR: %s !!!", strerror(err));
DBG1(DBG_LIB, "!!! RWLOCK UNLOCK ERROR: %s !!!", strerror(err));
}
}

12
src/libstrongswan/threading/thread.c
View File

@ -155,7 +155,7 @@ static void cancel(private_thread_t *this)
if (pthread_equal(this->thread_id, pthread_self()))
{
this->mutex->unlock(this->mutex);
DBG1("!!! CANNOT CANCEL CURRENT THREAD !!!");
DBG1(DBG_LIB, "!!! CANNOT CANCEL CURRENT THREAD !!!");
return;
}
#ifdef HAVE_PTHREAD_CANCEL
@ -180,7 +180,7 @@ static void _kill(private_thread_t *this, int sig)
* returned, so depending on the signal, the lock might not get
* unlocked. */
this->mutex->unlock(this->mutex);
DBG1("!!! CANNOT SEND SIGNAL TO CURRENT THREAD !!!");
DBG1(DBG_LIB, "!!! CANNOT SEND SIGNAL TO CURRENT THREAD !!!");
return;
}
pthread_kill(this->thread_id, sig);
@ -209,13 +209,13 @@ static void *join(private_thread_t *this)
if (pthread_equal(this->thread_id, pthread_self()))
{
this->mutex->unlock(this->mutex);
DBG1("!!! CANNOT JOIN CURRENT THREAD !!!");
DBG1(DBG_LIB, "!!! CANNOT JOIN CURRENT THREAD !!!");
return NULL;
}
if (this->detached_or_joined)
{
this->mutex->unlock(this->mutex);
DBG1("!!! CANNOT JOIN DETACHED THREAD !!!");
DBG1(DBG_LIB, "!!! CANNOT JOIN DETACHED THREAD !!!");
return NULL;
}
thread_id = this->thread_id;
@ -299,7 +299,7 @@ thread_t *thread_create(thread_main_t main, void *arg)
this->arg = arg;
if (pthread_create(&this->thread_id, NULL, (void*)thread_main, this) != 0)
{
DBG1("failed to create thread!");
DBG1(DBG_LIB, "failed to create thread!");
thread_destroy(this);
return NULL;
}
@ -354,7 +354,7 @@ void thread_cleanup_pop(bool execute)
(void**)&handler) != SUCCESS)
{
this->mutex->unlock(this->mutex);
DBG1("!!! THREAD CLEANUP ERROR !!!");
DBG1(DBG_LIB, "!!! THREAD CLEANUP ERROR !!!");
return;
}
this->mutex->unlock(this->mutex);

4
src/libstrongswan/utils.c
View File

@ -153,7 +153,7 @@ bool mkdir_p(const char *path, mode_t mode)
len = snprintf(full, sizeof(full)-1, "%s", path);
if (len < 0 || len >= sizeof(full)-1)
{
DBG1("path string %s too long", path);
DBG1(DBG_LIB, "path string %s too long", path);
return FALSE;
}
/* ensure that the path ends with a '/' */
@ -174,7 +174,7 @@ bool mkdir_p(const char *path, mode_t mode)
{
if (mkdir(full, mode) < 0)
{
DBG1("failed to create directory %s", full);
DBG1(DBG_LIB, "failed to create directory %s", full);
return FALSE;
}
}

10
src/libstrongswan/utils/enumerator.c
View File

@ -97,7 +97,8 @@ static bool enumerate_dir_enum(dir_enum_t *this, char **relative,
len = snprintf(this->full_end, remaining, "%s", entry->d_name);
if (len < 0 || len >= remaining)
{
DBG1("buffer too small to enumerate file '%s'", entry->d_name);
DBG1(DBG_LIB, "buffer too small to enumerate file '%s'",
entry->d_name);
return FALSE;
}
if (absolute)
@ -108,7 +109,8 @@ static bool enumerate_dir_enum(dir_enum_t *this, char **relative,
{
if (stat(this->full, st))
{
DBG1("stat() on '%s' failed: %s", this->full, strerror(errno));
DBG1(DBG_LIB, "stat() on '%s' failed: %s", this->full,
strerror(errno));
return FALSE;
}
}
@ -133,7 +135,7 @@ enumerator_t* enumerator_create_directory(char *path)
len = snprintf(this->full, sizeof(this->full)-1, "%s", path);
if (len < 0 || len >= sizeof(this->full)-1)
{
DBG1("path string '%s' too long", path);
DBG1(DBG_LIB, "path string '%s' too long", path);
free(this);
return NULL;
}
@ -148,7 +150,7 @@ enumerator_t* enumerator_create_directory(char *path)
this->dir = opendir(path);
if (this->dir == NULL)
{
DBG1("opening directory '%s' failed: %s", path, strerror(errno));
DBG1(DBG_LIB, "opening directory '%s' failed: %s", path, strerror(errno));
free(this);
return NULL;
}

2
src/libstrongswan/utils/host.c
View File

@ -482,7 +482,7 @@ host_t *host_create_from_dns(char *string, int af, u_int16_t port)
error = getaddrinfo(string, NULL, &hints, &result);
if (error != 0)
{
DBG1("resolving '%s' failed: %s", string, gai_strerror(error));
DBG1(DBG_LIB, "resolving '%s' failed: %s", string, gai_strerror(error));
return NULL;
}
/* result is a linked list, but we use only the first address */

7
src/libstrongswan/utils/optionsfrom.c
View File

@ -80,14 +80,15 @@ bool from(private_options_t *this, char *filename, int *argcp, char **argvp[],
this->nuses++;
if (this->nuses >= MAX_USES)
{
DBG1("optionsfrom called %d times by \"%s\" - looping?", this->nuses + 1, (*argvp)[0]);
DBG1(DBG_LIB, "optionsfrom called %d times by \"%s\" - looping?",
this->nuses + 1, (*argvp)[0]);
return FALSE;
}
fd = fopen(filename, "r");
if (fd == NULL)
{
DBG1("optionsfrom: unable to open file '%s': %s",
DBG1(DBG_LIB, "optionsfrom: unable to open file '%s': %s",
filename, strerror(errno));
return FALSE;
}
@ -132,7 +133,7 @@ bool from(private_options_t *this, char *filename, int *argcp, char **argvp[],
line.len--;
if (!extract_token(&token, delimiter, &line))
{
DBG1("optionsfrom: missing terminator at %s:%d",
DBG1(DBG_LIB, "optionsfrom: missing terminator at %s:%d",
filename, linepos);
good = FALSE;
break;

3
src/manager/main.c
View File

@ -48,7 +48,8 @@ int main (int arc, char *argv[])
database = lib->settings->get_str(lib->settings, "manager.database", NULL);
if (!database)
{
DBG1("database URI undefined, set manager.database in strongswan.conf");
DBG1(DBG_LIB, "database URI undefined, set manager.database "
"in strongswan.conf");
return 1;
}

11
src/openac/openac.c
View File

@ -105,7 +105,8 @@ static chunk_t read_serial(void)
}
else
{
DBG1(" file '%s' does not exist yet - serial number set to 01", OPENAC_SERIAL);
DBG1(DBG_LIB, " file '%s' does not exist yet - serial number "
"set to 01", OPENAC_SERIAL);
}
if (!serial.len)
{
@ -129,7 +130,7 @@ static void write_serial(chunk_t serial)
{
chunk_t hex_serial;
DBG1(" serial number is %#B", &serial);
DBG1(DBG_LIB, " serial number is %#B", &serial);
hex_serial = chunk_to_hex(serial, NULL, FALSE);
fprintf(fd, "%.*s\n", hex_serial.len, hex_serial.ptr);
fclose(fd);
@ -137,7 +138,7 @@ static void write_serial(chunk_t serial)
}
else
{
DBG1(" could not open file '%s' for writing", OPENAC_SERIAL);
DBG1(DBG_LIB, " could not open file '%s' for writing", OPENAC_SERIAL);
}
}
@ -431,7 +432,7 @@ int main(int argc, char **argv)
goto end;
}
DBG1("starting openac (strongSwan Version %s)", VERSION);
DBG1(DBG_LIB, "starting openac (strongSwan Version %s)", VERSION);
/* load the signer's RSA private key */
if (keyfile != NULL)
@ -444,7 +445,7 @@ int main(int argc, char **argv)
{
goto end;
}
DBG1(" loaded private key file '%s'", keyfile);
DBG1(DBG_LIB, " loaded private key file '%s'", keyfile);
}
/* load the signer's X.509 certificate */

8
src/pki/commands/issue.c
View File

@ -161,7 +161,7 @@ static int issue()
}
}
DBG2("Reading ca certificate:");
DBG2(DBG_LIB, "Reading ca certificate:");
ca = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_X509,
BUILD_FROM_FILE, cacert, BUILD_END);
if (!ca)
@ -182,7 +182,7 @@ static int issue()
goto end;
}
DBG2("Reading ca private key:");
DBG2(DBG_LIB, "Reading ca private key:");
private = lib->creds->create(lib->creds, CRED_PRIVATE_KEY,
public->get_type(public),
BUILD_FROM_FILE, cakey, BUILD_END);
@ -226,7 +226,7 @@ static int issue()
identification_t *subjectAltName;
pkcs10_t *req;
DBG2("Reading certificate request");
DBG2(DBG_LIB, "Reading certificate request");
if (file)
{
cert_req = lib->creds->create(lib->creds, CRED_CERTIFICATE,
@ -266,7 +266,7 @@ static int issue()
}
else
{
DBG2("Reading public key:");
DBG2(DBG_LIB, "Reading public key:");
if (file)
{
public = lib->creds->create(lib->creds, CRED_PUBLIC_KEY, KEY_ANY,

27
src/pluto/ac.c
View File

@ -88,16 +88,17 @@ bool ac_verify_cert(certificate_t *cert, bool strict)
cert_t *aacert;
time_t notBefore, valid_until;
DBG1("holder: '%Y'", subject);
DBG1("issuer: '%Y'", issuer);
DBG1(DBG_LIB, "holder: '%Y'", subject);
DBG1(DBG_LIB, "issuer: '%Y'", issuer);
if (!cert->get_validity(cert, NULL, NULL, &valid_until))
{
DBG1("attribute certificate is invalid (valid from %T to %T)",
DBG1(DBG_LIB, "attribute certificate is invalid (valid from %T to %T)",
&notBefore, FALSE, &valid_until, FALSE);
return FALSE;
}
DBG1("attribute certificate is valid until %T", &valid_until, FALSE);
DBG1(DBG_LIB, "attribute certificate is valid until %T", &valid_until,
FALSE);
lock_authcert_list("verify_x509acert");
aacert = get_authcert(issuer, authKeyID, X509_AA);
@ -105,17 +106,17 @@ bool ac_verify_cert(certificate_t *cert, bool strict)
if (aacert == NULL)
{
DBG1("issuer aacert not found");
DBG1(DBG_LIB, "issuer aacert not found");
return FALSE;
}
DBG2("issuer aacert found");
DBG2(DBG_LIB, "issuer aacert found");
if (!cert->issued_by(cert, aacert->cert))
{
DBG1("attribute certificate signature is invalid");
DBG1(DBG_LIB, "attribute certificate signature is invalid");
return FALSE;
}
DBG1("attribute certificate signature is valid");
DBG1(DBG_LIB, "attribute certificate signature is valid");
return verify_x509cert(aacert, strict, &valid_until);
}
@ -175,8 +176,8 @@ bool match_group_membership(ietf_attributes_t *peer_attributes, char *conn,
}
match = conn_attributes->matches(conn_attributes, peer_attributes);
DBG1("%s: peer with attributes '%s' is %sa member of the groups '%s'",
conn, peer_attributes->get_string(peer_attributes),
DBG1(DBG_LIB, "%s: peer with attributes '%s' is %sa member of the "
"groups '%s'", conn, peer_attributes->get_string(peer_attributes),
match ? "" : "not ", conn_attributes->get_string(conn_attributes));
return match;
@ -191,7 +192,7 @@ void ac_load_certs(void)
struct stat st;
char *file;
DBG1("loading attribute certificates from '%s'", A_CERT_PATH);
DBG1(DBG_LIB, "loading attribute certificates from '%s'", A_CERT_PATH);
enumerator = enumerator_create_directory(A_CERT_PATH);
if (!enumerator)
@ -212,7 +213,7 @@ void ac_load_certs(void)
BUILD_FROM_FILE, file, BUILD_END);
if (cert)
{
DBG1(" loaded attribute certificate from '%s'", file);
DBG1(DBG_LIB, " loaded attribute certificate from '%s'", file);
ac_add_cert(cert);
}
}
@ -266,7 +267,7 @@ void ac_list_certs(bool utc)
whack_log(RC_COMMENT, " hserial: %#B", &holderSerial);
}
groups = ac->get_groups(ac);
groups = ac->get_groups(ac);
if (groups)
{
whack_log(RC_COMMENT, " groups: %s", groups->get_string(groups));

4
src/pluto/ca.c
View File

@ -293,12 +293,12 @@ void load_authcerts(char *type, char *path, x509_flag_t auth_flags)
struct stat st;
char *file;
DBG1("loading %s certificates from '%s'", type, path);
DBG1(DBG_LIB, "loading %s certificates from '%s'", type, path);
enumerator = enumerator_create_directory(path);
if (!enumerator)
{
DBG1(" reading directory '%s' failed");
DBG1(DBG_LIB, " reading directory '%s' failed");
return;
}

11
src/pluto/fetch.c
View File

@ -266,10 +266,10 @@ x509crl_t* fetch_crl(char *url)
x509crl_t *crl;
chunk_t blob;
DBG1(" fetching crl from '%s' ...", url);
DBG1(DBG_LIB, " fetching crl from '%s' ...", url);
if (lib->fetcher->fetch(lib->fetcher, url, &blob, FETCH_END) != SUCCESS)
{
DBG1("crl fetching failed");
DBG1(DBG_LIB, "crl fetching failed");
return FALSE;
}
crl = lib->creds->create(lib->creds, CRED_CERTIFICATE, CERT_PLUTO_CRL,
@ -277,7 +277,8 @@ x509crl_t* fetch_crl(char *url)
free(blob.ptr);
if (!crl)
{
DBG1("crl fetched successfully but data coded in unknown format");
DBG1(DBG_LIB, "crl fetched successfully but data coded in unknown "
"format");
}
return crl;
}
@ -395,7 +396,7 @@ static void fetch_ocsp_status(ocsp_location_t* location)
chunk_t request = build_ocsp_request(location);
chunk_t response = chunk_empty;
DBG1(" requesting ocsp status from '%s' ...", location->uri);
DBG1(DBG_LIB, " requesting ocsp status from '%s' ...", location->uri);
if (lib->fetcher->fetch(lib->fetcher, location->uri, &response,
FETCH_REQUEST_DATA, request,
FETCH_REQUEST_TYPE, "application/ocsp-request",
@ -405,7 +406,7 @@ static void fetch_ocsp_status(ocsp_location_t* location)
}
else
{
DBG1("ocsp request to %s failed", location->uri);
DBG1(DBG_LIB, "ocsp request to %s failed", location->uri);
}
free(request.ptr);

88
src/pluto/pkcs7.c
View File

@ -146,7 +146,7 @@ bool pkcs7_parse_contentInfo(chunk_t blob, u_int level0, contentInfo_t *cInfo)
if (cInfo->type < OID_PKCS7_DATA
|| cInfo->type > OID_PKCS7_ENCRYPTED_DATA)
{
DBG1("unknown pkcs7 content type");
DBG1(DBG_LIB, "unknown pkcs7 content type");
goto end;
}
}
@ -187,7 +187,7 @@ bool pkcs7_parse_signedData(chunk_t blob, contentInfo_t *data,
}
if (cInfo.type != OID_PKCS7_SIGNED_DATA)
{
DBG1("pkcs7 content type is not signedData");
DBG1(DBG_LIB, "pkcs7 content type is not signedData");
return FALSE;
}
@ -202,7 +202,7 @@ bool pkcs7_parse_signedData(chunk_t blob, contentInfo_t *data,
{
case PKCS7_SIGNED_VERSION:
version = object.len ? (int)*object.ptr : 0;
DBG2(" v%d", version);
DBG2(DBG_LIB, " v%d", version);
break;
case PKCS7_DIGEST_ALG:
digest_alg = asn1_parse_algorithmIdentifier(object, level, NULL);
@ -217,7 +217,7 @@ bool pkcs7_parse_signedData(chunk_t blob, contentInfo_t *data,
{
certificate_t *cert;
DBG2(" parsing pkcs7-wrapped certificate");
DBG2(DBG_LIB, " parsing pkcs7-wrapped certificate");
cert = lib->creds->create(lib->creds,
CRED_CERTIFICATE, CERT_X509,
BUILD_BLOB_ASN1_DER, object,
@ -230,17 +230,17 @@ bool pkcs7_parse_signedData(chunk_t blob, contentInfo_t *data,
break;
case PKCS7_SIGNER_INFO:
signerInfos++;
DBG2(" signer #%d", signerInfos);
DBG2(DBG_LIB, " signer #%d", signerInfos);
break;
case PKCS7_SIGNER_INFO_VERSION:
version = object.len ? (int)*object.ptr : 0;
DBG2(" v%d", version);
DBG2(DBG_LIB, " v%d", version);
break;
case PKCS7_SIGNED_ISSUER:
{
identification_t *issuer = identification_create_from_encoding(
ID_DER_ASN1_DN, object);
DBG2(" \"%Y\"", issuer);
DBG2(DBG_LIB, " \"%Y\"", issuer);
issuer->destroy(issuer);
break;
}
@ -277,27 +277,27 @@ bool pkcs7_parse_signedData(chunk_t blob, contentInfo_t *data,
scheme = signature_scheme_from_oid(digest_alg);
if (scheme == SIGN_UNKNOWN)
{
DBG1("unsupported signature scheme");
DBG1(DBG_LIB, "unsupported signature scheme");
return FALSE;
}
if (signerInfos == 0)
{
DBG1("no signerInfo object found");
DBG1(DBG_LIB, "no signerInfo object found");
return FALSE;
}
else if (signerInfos > 1)
{
DBG1("more than one signerInfo object found");
DBG1(DBG_LIB, "more than one signerInfo object found");
return FALSE;
}
if (attributes->ptr == NULL)
{
DBG1("no authenticatedAttributes object found");
DBG1(DBG_LIB, "no authenticatedAttributes object found");
return FALSE;
}
if (enc_alg != OID_RSA_ENCRYPTION)
{
DBG1("only RSA digest encryption supported");
DBG1(DBG_LIB, "only RSA digest encryption supported");
return FALSE;
}
@ -305,16 +305,16 @@ bool pkcs7_parse_signedData(chunk_t blob, contentInfo_t *data,
key = cacert->get_public_key(cacert);
if (key == NULL)
{
DBG1("no public key found in CA certificate");
DBG1(DBG_LIB, "no public key found in CA certificate");
return FALSE;
}
if (key->verify(key, scheme, *attributes, encrypted_digest))
{
DBG2("signature is valid");
DBG2(DBG_LIB, "signature is valid");
}
else
{
DBG1("invalid signature");
DBG1(DBG_LIB, "invalid signature");
success = FALSE;
}
key->destroy(key);
@ -352,7 +352,7 @@ bool pkcs7_parse_envelopedData(chunk_t blob, chunk_t *data,
}
if (cInfo.type != OID_PKCS7_ENVELOPED_DATA)
{
DBG1("pkcs7 content type is not envelopedData");
DBG1(DBG_LIB, "pkcs7 content type is not envelopedData");
goto failed;
}
@ -367,19 +367,19 @@ bool pkcs7_parse_envelopedData(chunk_t blob, chunk_t *data,
{
case PKCS7_ENVELOPED_VERSION:
version = object.len ? (int)*object.ptr : 0;
DBG2(" v%d", version);
DBG2(DBG_LIB, " v%d", version);
if (version != 0)
{
DBG1("envelopedData version is not 0");
DBG1(DBG_LIB, "envelopedData version is not 0");
goto end;
}
break;
case PKCS7_RECIPIENT_INFO_VERSION:
version = object.len ? (int)*object.ptr : 0;
DBG2(" v%d", version);
DBG2(DBG_LIB, " v%d", version);
if (version != 0)
{
DBG1("recipient info version is not 0");
DBG1(DBG_LIB, "recipient info version is not 0");
goto end;
}
break;
@ -387,14 +387,14 @@ bool pkcs7_parse_envelopedData(chunk_t blob, chunk_t *data,
{
identification_t *issuer = identification_create_from_encoding(
ID_DER_ASN1_DN, object);
DBG2(" \"%Y\"", issuer);
DBG2(DBG_LIB, " \"%Y\"", issuer);
issuer->destroy(issuer);
break;
}
case PKCS7_SERIAL_NUMBER:
if (!chunk_equals(serialNumber, object))
{
DBG1("serial numbers do not match");
DBG1(DBG_LIB, "serial numbers do not match");
goto end;
}
break;
@ -402,22 +402,22 @@ bool pkcs7_parse_envelopedData(chunk_t blob, chunk_t *data,
enc_alg = asn1_parse_algorithmIdentifier(object, level, NULL);
if (enc_alg != OID_RSA_ENCRYPTION)
{
DBG1("only rsa encryption supported");
DBG1(DBG_LIB, "only rsa encryption supported");
goto end;
}
break;
case PKCS7_ENCRYPTED_KEY:
if (!key->decrypt(key, object, &symmetric_key))
{
DBG1("symmetric key could not be decrypted with rsa");
DBG1(DBG_LIB, "symmetric key could not be decrypted with rsa");
goto end;
}
DBG4("symmetric key %B", &symmetric_key);
DBG4(DBG_LIB, "symmetric key %B", &symmetric_key);
break;
case PKCS7_CONTENT_TYPE:
if (asn1_known_oid(object) != OID_PKCS7_DATA)
{
DBG1("encrypted content not of type pkcs7 data");
DBG1(DBG_LIB, "encrypted content not of type pkcs7 data");
goto end;
}
break;
@ -426,12 +426,12 @@ bool pkcs7_parse_envelopedData(chunk_t blob, chunk_t *data,
if (content_enc_alg == OID_UNKNOWN)
{
DBG1("unknown content encryption algorithm");
DBG1(DBG_LIB, "unknown content encryption algorithm");
goto end;
}
if (!asn1_parse_simple_object(&iv, ASN1_OCTET_STRING, level+1, "IV"))
{
DBG1("IV could not be parsed");
DBG1(DBG_LIB, "IV could not be parsed");
goto end;
}
break;
@ -459,28 +459,28 @@ end:
alg = encryption_algorithm_from_oid(content_enc_alg, &key_size);
if (alg == ENCR_UNDEFINED)
{
DBG1("unsupported content encryption algorithm");
DBG1(DBG_LIB, "unsupported content encryption algorithm");
goto failed;
}
crypter = lib->crypto->create_crypter(lib->crypto, alg, key_size);
if (crypter == NULL)
{
DBG1("crypter %N not available", encryption_algorithm_names, alg);
DBG1(DBG_LIB, "crypter %N not available", encryption_algorithm_names, alg);
goto failed;
}
if (symmetric_key.len != crypter->get_key_size(crypter))
{
DBG1("symmetric key length %d is wrong", symmetric_key.len);
DBG1(DBG_LIB, "symmetric key length %d is wrong", symmetric_key.len);
goto failed;
}
if (iv.len != crypter->get_block_size(crypter))
{
DBG1("IV length %d is wrong", iv.len);
DBG1(DBG_LIB, "IV length %d is wrong", iv.len);
goto failed;
}
crypter->set_key(crypter, symmetric_key);
crypter->decrypt(crypter, encrypted_content, iv, data);
DBG4("decrypted content with padding: %B", data);
DBG4(DBG_LIB, "decrypted content with padding: %B", data);
}
/* remove the padding */
@ -491,7 +491,7 @@ end:
if (padding > data->len)
{
DBG1("padding greater than data length");
DBG1(DBG_LIB, "padding greater than data length");
goto failed;
}
data->len -= padding;
@ -500,7 +500,7 @@ end:
{
if (*pos-- != pattern)
{
DBG1("wrong padding pattern");
DBG1(DBG_LIB, "wrong padding pattern");
goto failed;
}
}
@ -631,7 +631,7 @@ chunk_t pkcs7_build_signedData(chunk_t data, chunk_t attributes,
, asn1_wrap(ASN1_SET, "m", signerInfo));
cInfo = pkcs7_build_contentInfo(&signedData);
DBG3("signedData %B", &cInfo);
DBG3(DBG_LIB, "signedData %B", &cInfo);
free(pkcs7Data.content.ptr);
free(signedData.content.ptr);
@ -653,7 +653,7 @@ chunk_t pkcs7_build_envelopedData(chunk_t data, certificate_t *cert, int enc_alg
alg_key_size/BITS_PER_BYTE);
if (crypter == NULL)
{
DBG1("crypter for %N not available", encryption_algorithm_names, alg);
DBG1(DBG_LIB, "crypter for %N not available", encryption_algorithm_names, alg);
return chunk_empty;
}
@ -663,12 +663,12 @@ chunk_t pkcs7_build_envelopedData(chunk_t data, certificate_t *cert, int enc_alg
rng = lib->crypto->create_rng(lib->crypto, RNG_TRUE);
rng->allocate_bytes(rng, crypter->get_key_size(crypter), &symmetricKey);
DBG4("symmetric encryption key %B", &symmetricKey);
DBG4(DBG_LIB, "symmetric encryption key %B", &symmetricKey);
rng->destroy(rng);
rng = lib->crypto->create_rng(lib->crypto, RNG_WEAK);
rng->allocate_bytes(rng, crypter->get_block_size(crypter), &iv);
DBG4("initialization vector: %B", &iv);
DBG4(DBG_LIB, "initialization vector: %B", &iv);
rng->destroy(rng);
}
@ -680,7 +680,7 @@ chunk_t pkcs7_build_envelopedData(chunk_t data, certificate_t *cert, int enc_alg
in.len = data.len + padding;
in.ptr = malloc(in.len);
DBG2("padding %u bytes of data to multiple block size of %u bytes",
DBG2(DBG_LIB, "padding %u bytes of data to multiple block size of %u bytes",
data.len, in.len);
/* copy data */
@ -688,14 +688,14 @@ chunk_t pkcs7_build_envelopedData(chunk_t data, certificate_t *cert, int enc_alg
/* append padding */
memset(in.ptr + data.len, padding, padding);
}
DBG3("padded unencrypted data %B", &in);
DBG3(DBG_LIB, "padded unencrypted data %B", &in);
/* symmetric encryption of data object */
crypter->set_key(crypter, symmetricKey);
crypter->encrypt(crypter, in, iv, &out);
crypter->destroy(crypter);
chunk_clear(&in);
DBG3("encrypted data %B", &out);
DBG3(DBG_LIB, "encrypted data %B", &out);
/* protect symmetric key by public key encryption */
{
@ -703,7 +703,7 @@ chunk_t pkcs7_build_envelopedData(chunk_t data, certificate_t *cert, int enc_alg
if (key == NULL)
{
DBG1("public key not found in encryption certificate");
DBG1(DBG_LIB, "public key not found in encryption certificate");
chunk_clear(&symmetricKey);
chunk_free(&iv);
chunk_free(&out);
@ -744,7 +744,7 @@ chunk_t pkcs7_build_envelopedData(chunk_t data, certificate_t *cert, int enc_alg
, encryptedContentInfo);
cInfo = pkcs7_build_contentInfo(&envelopedData);
DBG3("envelopedData %B", &cInfo);
DBG3(DBG_LIB, "envelopedData %B", &cInfo);
chunk_free(&envelopedData.content);
chunk_free(&iv);

2
src/pluto/plutomain.c
View File

@ -244,7 +244,7 @@ static void print_plugins()
len += snprintf(&buf[len], BUF_LEN-len, "%s ", plugin);
}
enumerator->destroy(enumerator);
DBG1("loaded plugins: %s", buf);
DBG1(DBG_LIB, "loaded plugins: %s", buf);
}
int main(int argc, char **argv)

2
src/scepclient/scepclient.c
View File

@ -289,7 +289,7 @@ static void print_plugins()
len += snprintf(&buf[len], BUF_LEN-len, "%s ", plugin);
}
enumerator->destroy(enumerator);
DBG1(" loaded plugins: %s", buf);
DBG1(DBG_LIB, " loaded plugins: %s", buf);
}
/**