/*
* Return an allocated lttng hashtable.
*/
LTTNG_HIDDEN
struct lttng_ht *lttng_ht_new(unsigned long size, int type)
{
struct lttng_ht *ht;
/* Test size */
if (!size)
size = DEFAULT_HT_SIZE;
pthread_mutex_lock(&seed_lock);
if (!seed_init) {
lttng_ht_seed = (unsigned long) time(NULL);
seed_init = true;
}
pthread_mutex_unlock(&seed_lock);
ht = zmalloc(sizeof(*ht));
if (ht == NULL) {
PERROR("zmalloc lttng_ht");
goto error;
}
ht->ht = cds_lfht_new(size, min_hash_alloc_size, max_hash_buckets_size,
CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
/*
* There is already an assert in the RCU hashtable code so if the ht is
* NULL here there is a *huge* problem.
*/
assert(ht->ht);
switch (type) {
case LTTNG_HT_TYPE_STRING:
ht->match_fct = match_str;
ht->hash_fct = hash_key_str;
break;
case LTTNG_HT_TYPE_ULONG:
ht->match_fct = match_ulong;
ht->hash_fct = hash_key_ulong;
break;
case LTTNG_HT_TYPE_U64:
ht->match_fct = match_u64;
ht->hash_fct = hash_key_u64;
break;
case LTTNG_HT_TYPE_TWO_U64:
ht->match_fct = match_two_u64;
ht->hash_fct = hash_key_two_u64;
break;
default:
ERR("Unknown lttng hashtable type %d", type);
lttng_ht_destroy(ht);
goto error;
}
DBG3("Created hashtable size %lu at %p of type %d", size, ht->ht, type);
return ht;
error:
return NULL;
}
/*
* Enable UST channel for session and domain.
*/
int channel_ust_enable(struct ltt_ust_session *usess,
struct ltt_ust_channel *uchan)
{
int ret = LTTNG_OK;
assert(usess);
assert(uchan);
/* If already enabled, everything is OK */
if (uchan->enabled) {
DBG3("Channel %s already enabled. Skipping", uchan->name);
ret = LTTNG_ERR_UST_CHAN_EXIST;
goto end;
}
DBG2("Channel %s being enabled in UST domain", uchan->name);
/*
* Enable channel for UST global domain on all applications. Ignore return
* value here since whatever error we got, it means that the channel was
* not created on one or many registered applications and we can not report
* this to the user yet. However, at this stage, the channel was
* successfully created on the session daemon side so the enable-channel
* command is a success.
*/
(void) ust_app_enable_channel_glb(usess, uchan);
uchan->enabled = 1;
DBG2("Channel %s enabled successfully", uchan->name);
end:
return ret;
}
GList* DataStorage::lookup_network(const gchar *a_object_path) {
GList *item = NULL;
DBG3();
if(a_object_path == NULL) {
ERR("no object_path.");
return NULL;
}
if(m_list_networks == NULL) {
DBG2("network not found, list is empty.");
return NULL;
}
item = g_list_find_custom(m_list_networks, a_object_path, compare_object_path);
if(item != NULL) {
DBG2("network found");
return item;
}
else {
DBG2("network not found.");
}
return NULL;
}
void BuzzMDKHelper::MidiControlChange(const int ctrl, const int channel, const int value ) {
DBG3("(ctrl=%d,channel=%d,value=%d)\n",ctrl,channel,value);
/*
if( pInnerEx != NULL )
pInnerEx->MidiControlChange( ctrl, channel, value );
*/
}
/*
* Send a given stream to UST tracer.
*
* On success return 0 else a negative value.
*/
int ust_consumer_send_stream_to_ust(struct ust_app *app,
struct ust_app_channel *channel, struct ust_app_stream *stream)
{
int ret;
assert(app);
assert(stream);
assert(channel);
DBG2("UST consumer send stream to app %d", app->sock);
/* Relay stream to application. */
pthread_mutex_lock(&app->sock_lock);
ret = ustctl_send_stream_to_ust(app->sock, channel->obj, stream->obj);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
ERR("ustctl send stream handle %d to app pid: %d with ret %d",
stream->obj->handle, app->pid, ret);
} else {
DBG3("UST app send stream to ust failed. Application is dead.");
}
goto error;
}
channel->handle = channel->obj->handle;
error:
return ret;
}
LTTNG_HIDDEN
int run_as_extract_elf_symbol_offset(int fd, const char* function,
uid_t uid, gid_t gid, uint64_t *offset)
{
struct run_as_data data;
struct run_as_ret ret;
memset(&data, 0, sizeof(data));
memset(&ret, 0, sizeof(ret));
DBG3("extract_elf_symbol_offset() on fd=%d and function=%s "
"with for uid %d and gid %d", fd, function, (int) uid, (int) gid);
data.fd = fd;
strncpy(data.u.extract_elf_symbol_offset.function, function, LTTNG_SYMBOL_NAME_LEN - 1);
data.u.extract_elf_symbol_offset.function[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
run_as(RUN_AS_EXTRACT_ELF_SYMBOL_OFFSET, &data, &ret, uid, gid);
errno = ret._errno;
if (ret._error) {
return -1;
}
*offset = ret.u.extract_elf_symbol_offset.offset;
return 0;
}
/*
* Ask consumer to create a channel for a given session.
*
* Returns 0 on success else a negative value.
*/
int ust_consumer_ask_channel(struct ust_app_session *ua_sess,
struct ust_app_channel *ua_chan, struct consumer_output *consumer,
struct consumer_socket *socket, struct ust_registry_session *registry)
{
int ret;
assert(ua_sess);
assert(ua_chan);
assert(consumer);
assert(socket);
assert(registry);
if (!consumer->enabled) {
ret = -LTTNG_ERR_NO_CONSUMER;
DBG3("Consumer is disabled");
goto error;
}
pthread_mutex_lock(socket->lock);
ret = ask_channel_creation(ua_sess, ua_chan, consumer, socket, registry);
pthread_mutex_unlock(socket->lock);
if (ret < 0) {
goto error;
}
error:
return ret;
}
LTTNG_HIDDEN
int run_as_mkdirat(int dirfd, const char *path, mode_t mode,
uid_t uid, gid_t gid)
{
int ret;
struct run_as_data data;
struct run_as_ret run_as_ret;
memset(&data, 0, sizeof(data));
memset(&run_as_ret, 0, sizeof(run_as_ret));
DBG3("mkdirat() recursive fd = %d%s, path = %s, mode = %d, uid = %d, gid = %d",
dirfd, dirfd == AT_FDCWD ? " (AT_FDCWD)" : "",
path, (int) mode, (int) uid, (int) gid);
ret = lttng_strncpy(data.u.mkdirat.path, path,
sizeof(data.u.mkdirat.path));
if (ret) {
ERR("Failed to copy path argument of mkdirat command");
goto error;
}
data.u.mkdirat.path[PATH_MAX - 1] = '\0';
data.u.mkdirat.mode = mode;
data.fd = dirfd;
run_as(dirfd == AT_FDCWD ? RUN_AS_MKDIR : RUN_AS_MKDIRAT,
&data, &run_as_ret, uid, gid);
errno = run_as_ret._errno;
ret = run_as_ret._errno;
error:
return ret;
}
gint ConnmanManager::add_service(ConnmanService *a_service) {
ConnmanService *service = NULL;
gint ret = 0;
DBG3();
if(a_service == NULL) {
ERR("no connman service '%p'", a_service);
return -1;
}
if(m_services == NULL) {
ERR("no services available.");
return -1;
}
service = lookup_service(a_service->get_object_path());
if(service != NULL) {
DBG("service '%s' already exists.", service->get_object_path());
return 0;
}
DBG("add new service '%s'.", a_service->get_object_path());
g_hash_table_insert(m_services, (gchar *)a_service->get_object_path(), a_service);
return 0;
}
/*
* Receive reply data on socket. This MUST be call after send_command or else
* could result in unexpected behavior(s).
*/
static int recv_reply(struct lttcomm_relayd_sock *rsock, void *data, size_t size)
{
int ret;
if (rsock->sock.fd < 0) {
return -ECONNRESET;
}
DBG3("Relayd waiting for reply of size %zu", size);
ret = rsock->sock.ops->recvmsg(&rsock->sock, data, size, 0);
if (ret <= 0 || ret != size) {
if (ret == 0) {
/* Orderly shutdown. */
DBG("Socket %d has performed an orderly shutdown", rsock->sock.fd);
} else {
DBG("Receiving reply failed on sock %d for size %zu with ret %d",
rsock->sock.fd, size, ret);
}
/* Always return -1 here and the caller can use errno. */
ret = -1;
goto error;
}
error:
return ret;
}
void DataStorage::delete_network(const gchar *a_object_path) {
GList *item = NULL;
INetwork *network = NULL;
DBG3();
if(a_object_path == NULL) {
ERR("no object_path.");
return;
}
item = lookup_network(a_object_path);
if(item == NULL) {
ERR("network '%s' not found", a_object_path);
return;
}
DBG("delete network '%s'", a_object_path);
network = (INetwork *)item->data;
delete network;
m_list_networks = g_list_remove_link(m_list_networks, item);
g_list_free_1(item);
}
/*
* Send data header structure to the relayd.
*/
int relayd_send_data_hdr(struct lttcomm_relayd_sock *rsock,
struct lttcomm_relayd_data_hdr *hdr, size_t size)
{
int ret;
/* Code flow error. Safety net. */
assert(rsock);
assert(hdr);
if (rsock->sock.fd < 0) {
return -ECONNRESET;
}
DBG3("Relayd sending data header of size %zu", size);
/* Again, safety net */
if (size == 0) {
size = sizeof(struct lttcomm_relayd_data_hdr);
}
/* Only send data header. */
ret = rsock->sock.ops->sendmsg(&rsock->sock, hdr, size, 0);
if (ret < 0) {
ret = -errno;
goto error;
}
/*
* The data MUST be sent right after that command for the receive on the
* other end to match the size in the header.
*/
error:
return ret;
}
/*
* Close relayd socket with an allocated lttcomm_relayd_sock.
*
* If no socket operations are found, simply return 0 meaning that everything
* is fine. Without operations, the socket can not possibly be opened or used.
* This is possible if the socket was allocated but not created. However, the
* caller could simply use it to store a valid file descriptor for instance
* passed over a Unix socket and call this to cleanup but still without a valid
* ops pointer.
*
* Return the close returned value. On error, a negative value is usually
* returned back from close(2).
*/
int relayd_close(struct lttcomm_relayd_sock *rsock)
{
int ret;
/* Code flow error. Safety net. */
assert(rsock);
/* An invalid fd is fine, return success. */
if (rsock->sock.fd < 0) {
ret = 0;
goto end;
}
DBG3("Relayd closing socket %d", rsock->sock.fd);
if (rsock->sock.ops) {
ret = rsock->sock.ops->close(&rsock->sock);
} else {
/* Default call if no specific ops found. */
ret = close(rsock->sock.fd);
if (ret < 0) {
PERROR("relayd_close default close");
}
}
rsock->sock.fd = -1;
end:
return ret;
}
/*
* Send channel previously received from the consumer to the UST tracer.
*
* On success return 0 else a negative value.
*/
int ust_consumer_send_channel_to_ust(struct ust_app *app,
struct ust_app_session *ua_sess, struct ust_app_channel *channel)
{
int ret;
assert(app);
assert(ua_sess);
assert(channel);
assert(channel->obj);
DBG2("UST app send channel to sock %d pid %d (name: %s, key: %" PRIu64 ")",
app->sock, app->pid, channel->name, channel->tracing_channel_id);
/* Send stream to application. */
pthread_mutex_lock(&app->sock_lock);
ret = ustctl_send_channel_to_ust(app->sock, ua_sess->handle, channel->obj);
pthread_mutex_unlock(&app->sock_lock);
if (ret < 0) {
if (ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
ERR("Error ustctl send channel %s to app pid: %d with ret %d",
channel->name, app->pid, ret);
} else {
DBG3("UST app send channel to ust failed. Application is dead.");
}
goto error;
}
error:
return ret;
}
gint ConnmanManager::delete_service(const gchar *a_object_path) {
ConnmanService *service = NULL;
DBG3();
if(a_object_path == NULL) {
ERR("no object path.");
return -1;
}
if(m_services == NULL) {
ERR("no services available.");
return -1;
}
service = lookup_service(a_object_path);
if(service == NULL) {
DBG("service does not exists.", a_object_path);
return 0;
}
DBG("delete service '%s'.", a_object_path);
g_hash_table_remove(m_services, a_object_path);
delete service;
return 0;
}
/*
* Connect to relay daemon with an allocated lttcomm_sock.
*/
int relayd_connect(struct lttcomm_sock *sock)
{
/* Code flow error. Safety net. */
assert(sock);
DBG3("Relayd connect ...");
return sock->ops->connect(sock);
}
gint ConnmanManager::verdict_ho(const gchar *a_object_path) {
ConnmanService *service = NULL;
gint err = 0;
DBG3();
g_static_mutex_lock(&services_mutex);
service = lookup_service(a_object_path);
if(service == NULL) {
ERR("service does not exists.", a_object_path);
err = -1;
goto end;
}
DBG("object path '%s'.", a_object_path);
if(service->get_active_service() == NULL) {
ERR("no active service.");
err = -1;
goto end;
}
else if(service == service->get_active_service()) {
DBG("service already connected");
err = 0;
goto end;
}
if((service->get_state() == StateIdle) || (service->get_state() == StateAssociation)) {
err = service->connect_sync();
if(err < 0) {
ERR("connecting");
goto end;
}
}
if(service->get_state() == StateReady) {
DBG("active service '%s'", service->get_active_service()->get_object_path());
err = service->move_before(service->get_active_service()->get_object_path());
if(err < 0) {
ERR("handover");
goto end;
}
}
end:
g_static_mutex_unlock(&services_mutex);
return err;
}
void set_Arm (unsigned char mode)
{
#ifdef CMM_ARM_EXPERIMENT
unsigned long cur_pos;
unsigned char old_mode;
unsigned char pct_deployed;
get_ArmPosition(&cur_pos, &old_mode);
if (mode == old_mode) return;
if (old_mode != ARM_STOP)
{
if (cur_pos != arm_pos)
{
pct_deployed = cur_pos / ARM_STROKE_PCT;
#ifdef ARM_POS_DEBUG
DBG("Arm moved ");
if (cur_pos > arm_pos)
DBG2("+%lu", cur_pos - arm_pos);
else
DBG2("-%lu", arm_pos - cur_pos);
DBG3(" to %lu (%lu)\n", cur_pos, pct_deployed);
#endif
arm_pos = cur_pos;
}
}
else
{
pct_deployed = cur_pos / ARM_STROKE_PCT;
}
if (mode != ARM_STOP) gettimestamp(&arm_start);
#endif
switch (mode) {
default:
case ARM_STOP:
ARM(LAT) &= ~(ARM_UPDOWN_MASK | ARM_ONOFF_MASK);
break;
case ARM_UP:
ARM(LAT) &= ~ARM_UPDOWN_MASK;
ARM(LAT) |= ARM_ONOFF_MASK;
break;
case ARM_DOWN:
ARM(LAT) |= ARM_UPDOWN_MASK;
ARM(LAT) |= ARM_ONOFF_MASK;
break;
}
#ifdef CMM_ARM_EXPERIMENT
// % deployed in lower bits, mode in upper bits
eventlog_track(EVENTLOG_ARM, (((uint16_t)pct_deployed) << 8) | mode);
#else
eventlog_track(EVENTLOG_ARM, mode);
#endif
}
int load_pkcs11_module(const char *module, pkcs11_handle_t **hp)
{
int rv;
struct stat module_stat;
CK_C_GetFunctionList C_GetFunctionList_ptr;
pkcs11_handle_t *h;
DBG1("PKCS #11 module = [%s]", module);
/* reset pkcs #11 handle */
h = (pkcs11_handle_t *)calloc(sizeof(pkcs11_handle_t), 1);
if (h == NULL) {
set_error("pkcs11_handle_t malloc failed: %s", strerror(errno));
return -1;
}
/* check module permissions */
rv = stat(module, &module_stat);
if (rv < 0) {
set_error("stat() failed: %s", strerror(errno));
free(h);
return -1;
}
DBG3("module permissions: uid = %d, gid = %d, mode = %o",
module_stat.st_uid, module_stat.st_gid, module_stat.st_mode & 0777);
if (module_stat.st_mode & S_IWGRP || module_stat.st_mode & S_IWOTH
|| module_stat.st_uid != 0) {
set_error("the pkcs #11 module MUST be owned by root and MUST NOT "
"be writable by the group or others");
free(h);
return -1;
}
/* load module */
DBG1("loading module %s", module);
h->module_handle = dlopen(module, RTLD_NOW);
if (h->module_handle == NULL) {
set_error("dlopen() failed: %s", dlerror());
free(h);
return -1;
}
/* try to get the function list */
DBG("getting function list");
C_GetFunctionList_ptr = (CK_C_GetFunctionList)dlsym(h->module_handle, "C_GetFunctionList");
if (C_GetFunctionList_ptr == NULL) {
set_error("dlsym() failed: %s", dlerror());
free(h);
return -1;
}
rv = C_GetFunctionList_ptr(&h->fl);
if (rv != CKR_OK) {
set_error("C_GetFunctionList() failed: 0x%08lX", rv);
free(h);
return -1;
}
*hp = h;
return 0;
}
void* ConnmanManager::helper(gpointer a_user_data) {
ConnmanManager *manager = reinterpret_cast<ConnmanManager *>(a_user_data);
DBG3("manager '%p'", manager);
manager->run();
return NULL;
}
/**
* create a signed pkcs7 contentInfo object
*/
chunk_t pkcs7_build_signedData(chunk_t data, chunk_t attributes,
certificate_t *cert, int digest_alg,
private_key_t *key)
{
contentInfo_t pkcs7Data, signedData;
chunk_t authenticatedAttributes = chunk_empty;
chunk_t encryptedDigest = chunk_empty;
chunk_t signerInfo, cInfo, signature, encoding = chunk_empty;;
signature_scheme_t scheme = signature_scheme_from_oid(digest_alg);
if (attributes.ptr)
{
if (key->sign(key, scheme, attributes, &signature))
{
encryptedDigest = asn1_wrap(ASN1_OCTET_STRING, "m", signature);
authenticatedAttributes = chunk_clone(attributes);
*authenticatedAttributes.ptr = ASN1_CONTEXT_C_0;
}
}
else if (data.ptr)
{
if (key->sign(key, scheme, data, &signature))
{
encryptedDigest = asn1_wrap(ASN1_OCTET_STRING, "m", signature);
}
}
signerInfo = asn1_wrap(ASN1_SEQUENCE, "cmmmmm"
, ASN1_INTEGER_1
, pkcs7_build_issuerAndSerialNumber(cert)
, asn1_algorithmIdentifier(digest_alg)
, authenticatedAttributes
, asn1_algorithmIdentifier(OID_RSA_ENCRYPTION)
, encryptedDigest);
pkcs7Data.type = OID_PKCS7_DATA;
pkcs7Data.content = (data.ptr == NULL)? chunk_empty
: asn1_simple_object(ASN1_OCTET_STRING, data);
cert->get_encoding(cert, CERT_ASN1_DER, &encoding);
signedData.type = OID_PKCS7_SIGNED_DATA;
signedData.content = asn1_wrap(ASN1_SEQUENCE, "cmmmm"
, ASN1_INTEGER_1
, asn1_wrap(ASN1_SET, "m", asn1_algorithmIdentifier(digest_alg))
, pkcs7_build_contentInfo(&pkcs7Data)
, asn1_wrap(ASN1_CONTEXT_C_0, "m", encoding)
, asn1_wrap(ASN1_SET, "m", signerInfo));
cInfo = pkcs7_build_contentInfo(&signedData);
DBG3(DBG_LIB, "signedData %B", &cInfo);
free(pkcs7Data.content.ptr);
free(signedData.content.ptr);
return cInfo;
}
LTTNG_HIDDEN
int run_as_unlink(const char *path, uid_t uid, gid_t gid)
{
struct run_as_data data;
DBG3("unlink() %s with for uid %d and gid %d",
path, (int) uid, (int) gid);
strncpy(data.u.unlink.path, path, PATH_MAX - 1);
data.u.unlink.path[PATH_MAX - 1] = '\0';
return run_as(RUN_AS_UNLINK, &data, uid, gid);
}
LTTNG_HIDDEN
int run_as_rmdir_recursive(const char *path, uid_t uid, gid_t gid)
{
struct run_as_data data;
DBG3("rmdir_recursive() %s with for uid %d and gid %d",
path, (int) uid, (int) gid);
strncpy(data.u.rmdir_recursive.path, path, PATH_MAX - 1);
data.u.rmdir_recursive.path[PATH_MAX - 1] = '\0';
return run_as(RUN_AS_RMDIR_RECURSIVE, &data, uid, gid);
}
void PdParamGetter::getParamFromPd(pd::PdBase * pd) {
// parsedString.clear();
guiSizes.clear();
guiFiles.clear();
pulpParameterDescs.clear();
localObjectCount =0;
localParamCount = 0;
GUINumParams.clear();
GUINumObjects.clear();
t_canvas * x;// = pd_getcanvaslist();
pd->setMainContext();
bool isRoot = true;
for(x= pd_getcanvaslist(); x; x = x->gl_next) {
DBG3(x->gl_name->s_name,x->gl_env->ce_dir->s_name,x->gl_env->ce_argc);
if(isRoot) {
guiFiles.add(File(x->gl_env->ce_dir->s_name).getChildFile(x->gl_name->s_name));
PdRootName =x->gl_name->s_name;
isRoot = false;
}
// DBG4(x->gl_screenx1,x->gl_screeny1,x->gl_screenx2,x->gl_screeny2)
int guiIdx = 0;
Rectangle<int> patchRect (x->gl_screenx2-x->gl_screenx1,x->gl_screeny2-x->gl_screeny1);
guiSizes.add(patchRect);
DBG(patchRect.toString());
int tmpCount = localParamCount;
int tmpObjCount = localObjectCount;
getFromPdCanvas(x,guiIdx);
guiIdx++;
// if(pulpParameterDescs.size()>0){
// float minX = std::min(std::min(minX, pulpParameterDescs[0]->getX()),pulpParameterDescs[0]->labelRect.getX()) ;
// float minY = std::min(std::min(minY, pulpParameterDescs[0]->getY()),pulpParameterDescs[0]->labelRect.getY()) ;
//
// for(auto & p:pulpParameterDescs){
// minX = std::min(std::min(minX, p->getX()),p->labelRect.getX()) ;
// minY = std::min(std::min(minY, p->getY()),p->labelRect.getY()) ;
// }
// for(auto & p:pulpParameterDescs){
// p->setPosition( p->getX()-minX,p->getY()-minY);
// }
// }
GUINumObjects.add(localObjectCount - tmpObjCount);
GUINumParams.add(localParamCount-tmpCount);
}
pd->freeContext();
}
LTTNG_HIDDEN
int run_as_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid)
{
struct run_as_data data;
DBG3("mkdir() %s with mode %d for uid %d and gid %d",
path, (int) mode, (int) uid, (int) gid);
strncpy(data.u.mkdir.path, path, PATH_MAX - 1);
data.u.mkdir.path[PATH_MAX - 1] = '\0';
data.u.mkdir.mode = mode;
return run_as(RUN_AS_MKDIR, &data, uid, gid);
}
void ConnmanManager::run() {
m_do_logging = TRUE;
DBG3();
while(m_do_logging) {
request_services_sync();
usleep(m_interval*1000);
}
}
LTTNG_HIDDEN
int run_as_open(const char *path, int flags, mode_t mode, uid_t uid, gid_t gid)
{
struct run_as_data data;
DBG3("open() %s with flags %X mode %d for uid %d and gid %d",
path, flags, (int) mode, (int) uid, (int) gid);
strncpy(data.u.open.path, path, PATH_MAX - 1);
data.u.open.path[PATH_MAX - 1] = '\0';
data.u.open.flags = flags;
data.u.open.mode = mode;
return run_as(RUN_AS_OPEN, &data, uid, gid);
}
/*
* Send command. Fill up the header and append the data.
*/
static int send_command(struct lttcomm_relayd_sock *rsock,
enum lttcomm_relayd_command cmd, void *data, size_t size,
int flags)
{
int ret;
struct lttcomm_relayd_hdr header;
char *buf;
uint64_t buf_size = sizeof(header);
if (rsock->sock.fd < 0) {
return -ECONNRESET;
}
if (data) {
buf_size += size;
}
buf = zmalloc(buf_size);
if (buf == NULL) {
PERROR("zmalloc relayd send command buf");
ret = -1;
goto alloc_error;
}
memset(&header, 0, sizeof(header));
header.cmd = htobe32(cmd);
header.data_size = htobe64(size);
/* Zeroed for now since not used. */
header.cmd_version = 0;
header.circuit_id = 0;
/* Prepare buffer to send. */
memcpy(buf, &header, sizeof(header));
if (data) {
memcpy(buf + sizeof(header), data, size);
}
ret = rsock->sock.ops->sendmsg(&rsock->sock, buf, buf_size, flags);
if (ret < 0) {
ret = -errno;
goto error;
}
DBG3("Relayd sending command %d of size %" PRIu64, cmd, buf_size);
error:
free(buf);
alloc_error:
return ret;
}
ConnmanService* ConnmanManager::create_service(const gchar *a_object_path) {
ConnmanService *service = NULL;
gint ret = 0;
DBG3();
if(a_object_path == NULL) {
ERR("no object path.");
return NULL;
}
DBG("object path '%s'.", a_object_path);
if(m_services == NULL) {
m_services = g_hash_table_new(g_str_hash, g_str_equal);
if(m_services == NULL) {
ERR("cannot create hash table for services.");
return NULL;
}
}
service = lookup_service(a_object_path);
if(service != NULL) {
DBG("service '%s' already exists.", a_object_path);
return service;
}
DBG("create new service '%s'.", a_object_path);
service = new ConnmanService(get_service_name(), a_object_path, CONNMAN_SERVICE_INTERFACE);
if(service == NULL) {
ERR("cannot allocate new connman service.");
return NULL;
}
ret = service->create_service_sync();
if(ret < 0) {
ERR("cannot create new connman service.");
delete service;
return NULL;
}
return service;
}
gint ConnmanManager::start() {
DBG3();
DBG("start thread.");
m_thread = g_thread_create(helper, this, TRUE, NULL);
if(m_thread == NULL) {
ERR("thread cannot start.");
return -1;
}
return 0;
}
