Exemple #1
0
static int create_handover_agent(const char *sender, const char *path,
					enum ho_agent_carrier carrier)
{
	struct near_handover_agent *agent;

	agent = g_try_malloc0(sizeof(struct near_handover_agent));
	if (!agent)
		return -ENOMEM;

	agent->sender = g_strdup(sender);
	agent->path = g_strdup(path);
	agent->carrier = carrier;
	agent->watch = g_dbus_add_disconnect_watch(connection, sender,
				 handover_agent_disconnect, agent, NULL);

	g_hash_table_insert(ho_agent_hash, GINT_TO_POINTER(carrier), agent);

	DBG("handover agent registered");

	switch (agent->carrier) {
	case HO_AGENT_BT:
		/* stop watching for legacy bluez */
		__near_bluetooth_legacy_stop();
		break;

	case HO_AGENT_WIFI:
	case HO_AGENT_UNKNOWN:
		break;
	}

	return 0;
}
Exemple #2
0
/**
 * Convert a numeric frequency value to the "natural" string representation
 * of its period.
 *
 * E.g. a value of 3000000 would be converted to "3 us", 20000 to "50 ms".
 *
 * @param frequency The frequency in Hz.
 *
 * @return A g_try_malloc()ed string representation of the frequency value,
 *         or NULL upon errors. The caller is responsible to g_free() the
 *         memory.
 */
SR_API char *sr_period_string(uint64_t frequency)
{
	char *o;
	int r;

	/* Allocate enough for a uint64_t as string + " ms". */
	if (!(o = g_try_malloc0(30 + 1))) {
		sr_err("%s: o malloc failed", __func__);
		return NULL;
	}

	if (frequency >= SR_GHZ(1))
		r = snprintf(o, 30, "%" PRIu64 " ns", frequency / 1000000000);
	else if (frequency >= SR_MHZ(1))
		r = snprintf(o, 30, "%" PRIu64 " us", frequency / 1000000);
	else if (frequency >= SR_KHZ(1))
		r = snprintf(o, 30, "%" PRIu64 " ms", frequency / 1000);
	else
		r = snprintf(o, 30, "%" PRIu64 " s", frequency);

	if (r < 0) {
		/* Something went wrong... */
		g_free(o);
		return NULL;
	}

	return o;
}
Exemple #3
0
/**
 * Convert a numeric voltage value to the "natural" string representation
 * of its voltage value. The voltage is specified as a rational number's
 * numerator and denominator.
 *
 * E.g. a value of 300000 would be converted to "300mV", 2 to "2V".
 *
 * @param v_p The voltage numerator.
 * @param v_q The voltage denominator.
 *
 * @return A g_try_malloc()ed string representation of the voltage value,
 *         or NULL upon errors. The caller is responsible to g_free() the
 *         memory.
 */
SR_API char *sr_voltage_string(uint64_t v_p, uint64_t v_q)
{
	int r;
	char *o;

	if (!(o = g_try_malloc0(30 + 1))) {
		sr_err("%s: o malloc failed", __func__);
		return NULL;
	}

	if (v_q == 1000)
		r = snprintf(o, 30, "%" PRIu64 "mV", v_p);
	else if (v_q == 1)
		r = snprintf(o, 30, "%" PRIu64 "V", v_p);
	else
		r = snprintf(o, 30, "%gV", (float)v_p / (float)v_q);

	if (r < 0) {
		/* Something went wrong... */
		g_free(o);
		return NULL;
	}

	return o;
}
Exemple #4
0
static GAtPPP *ppp_init_common(GAtHDLC *hdlc, gboolean is_server, guint32 ip)
{
	GAtPPP *ppp;

	ppp = g_try_malloc0(sizeof(GAtPPP));
	if (ppp == NULL)
		return NULL;

	ppp->hdlc = g_at_hdlc_ref(hdlc);

	ppp->ref_count = 1;

	/* set options to defaults */
	ppp->mru = DEFAULT_MRU;
	ppp->mtu = DEFAULT_MTU;

	/* initialize the lcp state */
	ppp->lcp = lcp_new(ppp, is_server);

	/* initialize IPCP state */
	ppp->ipcp = ipcp_new(ppp, is_server, ip);

	g_at_hdlc_set_receive(ppp->hdlc, ppp_receive, ppp);
	g_at_io_set_disconnect_function(g_at_hdlc_get_io(ppp->hdlc),
						io_disconnect, ppp);

	if (is_server)
		ppp_enter_phase(ppp, PPP_PHASE_ESTABLISHMENT);

	return ppp;
}
Exemple #5
0
static void extract_addr(DBusMessageIter *value,
					struct supplicant_result *result)
{
	DBusMessageIter array;
	struct ether_addr eth;
	unsigned char *addr;
	int addr_len;

	dbus_message_iter_recurse(value, &array);
	dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);

	if (addr_len != 6)
		return;

	result->addr = g_try_malloc(addr_len);
	if (result->addr == NULL)
		return;

	memcpy(result->addr, addr, addr_len);
	result->addr_len = addr_len;

	result->path = g_try_malloc0(13);
	if (result->path == NULL)
		return;

	memcpy(&eth, addr, sizeof(eth));
	snprintf(result->path, 13, "%02x%02x%02x%02x%02x%02x",
						eth.ether_addr_octet[0],
						eth.ether_addr_octet[1],
						eth.ether_addr_octet[2],
						eth.ether_addr_octet[3],
						eth.ether_addr_octet[4],
						eth.ether_addr_octet[5]);
}
Exemple #6
0
SR_PRIV int event(struct sr_output *o, int event_type, uint8_t **data_out,
		  uint64_t *length_out)
{
	struct context *ctx;
	int outsize;
	uint8_t *outbuf;

	ctx = o->internal;
	switch (event_type) {
	case SR_DF_TRIGGER:
		ctx->mark_trigger = ctx->spl_cnt;
		*data_out = NULL;
		*length_out = 0;
		break;
	case SR_DF_END:
		outsize = ctx->num_enabled_probes
				* (ctx->samples_per_line + 20) + 512;
		if (!(outbuf = g_try_malloc0(outsize))) {
			sr_err("text out: %s: outbuf malloc failed", __func__);
			return SR_ERR_MALLOC;
		}
		flush_linebufs(ctx, outbuf);
		*data_out = outbuf;
		*length_out = strlen((const char *)outbuf);
		g_free(o->internal);
		o->internal = NULL;
		break;
	default:
		*data_out = NULL;
		*length_out = 0;
		break;
	}

	return SR_OK;
}
/*****************************************************************************
 * neardal_handoveragent_prv_manage: create or release an agent and register
 * or unregister it with neardal object manager and Neard
 ****************************************************************************/
errorCode_t neardal_handoveragent_prv_manage(
					neardal_handover_agent_t agentData)
{
        errorCode_t			err = NEARDAL_SUCCESS;
        neardalObjectSkeleton		*objSkel;
        neardalHandoverAgent		*handoverAgent;
        neardal_handover_agent_t	*data;

        NEARDAL_TRACEIN();

        if (agentData.cb_oob_push_agent != NULL &&
	    agentData.cb_oob_req_agent != NULL) {
                data = g_try_malloc0(sizeof(neardal_handover_agent_t));
                if (data == NULL)
                        return NEARDAL_ERROR_NO_MEMORY;

                memcpy(data, &agentData, sizeof(neardal_handover_agent_t));
                data->objPath = g_strdup(agentData.objPath);
                data->carrierType = g_strdup(agentData.carrierType);

                NEARDAL_TRACEF("Create agent '%s'\n", data->objPath);
                objSkel = neardal_object_skeleton_new (data->objPath);

                handoverAgent = neardal_handover_agent_skeleton_new();
                neardal_object_skeleton_set_handover_agent(objSkel,
                                                          handoverAgent);

                /* Handle RequestOOB() D-Bus method invocations */
                g_signal_connect( handoverAgent, "handle-request-oob"
                                , G_CALLBACK (on_RequestOOB)
                                , data);

                /* Handle PushOOB() D-Bus method invocations */
                g_signal_connect( handoverAgent, "handle-push-oob"
                                , G_CALLBACK (on_PushOOB)
                                , data);

                /* Handle Release D-Bus method invocations */
                g_signal_connect( handoverAgent, "handle-release"
                                , G_CALLBACK (on_Handover_Release), data);

                g_signal_connect( neardalMgr.agentMgr, "object-removed"
                                , G_CALLBACK (on_handover_object_removed)
				 , data);
                g_object_unref(handoverAgent);

                /* Export the object */
                g_dbus_object_manager_server_export(neardalMgr.agentMgr
                                        , G_DBUS_OBJECT_SKELETON (objSkel));
                g_object_unref (objSkel);
        } else {
                NEARDAL_TRACEF("Release agent '%s'\n", agentData.objPath);
                if (neardal_agent_prv_remove(agentData.objPath) == TRUE)
                        err = NEARDAL_SUCCESS;
                else
                        err = NEARDAL_ERROR_DBUS;
        }

        return err;
}
Exemple #8
0
static bool
plugin_mapping_new(zathura_plugin_manager_t* plugin_manager, const gchar* type, zathura_plugin_t* plugin)
{
  g_return_val_if_fail(plugin_manager != NULL, false);
  g_return_val_if_fail(type           != NULL, false);
  g_return_val_if_fail(plugin         != NULL, false);

  GIRARA_LIST_FOREACH(plugin_manager->type_plugin_mapping, zathura_type_plugin_mapping_t*, iter, mapping)
  if (g_content_type_equals(type, mapping->type)) {
    girara_list_iterator_free(iter);
    return false;
  }
  GIRARA_LIST_FOREACH_END(plugin_manager->type_plugin_mapping, zathura_type_plugin_mapping_t*, iter, mapping);

  zathura_type_plugin_mapping_t* mapping = g_try_malloc0(sizeof(zathura_type_plugin_mapping_t));
  if (mapping == NULL) {
    return false;
  }

  mapping->type   = g_strdup(type);
  mapping->plugin = plugin;
  girara_list_append(plugin_manager->type_plugin_mapping, mapping);

  return true;
}
Exemple #9
0
mc_config_t *
mc_config_init (const gchar * ini_path)
{
    mc_config_t *mc_config;
    struct stat st;

    mc_config = g_try_malloc0 (sizeof (mc_config_t));

    if (mc_config == NULL)
        return NULL;

    mc_config->handle = g_key_file_new ();
    if (mc_config->handle == NULL) {
        g_free (mc_config);
        return NULL;
    }
    if (!ini_path || !exist_file (ini_path)) {
        return mc_config;
    }

    if (!mc_stat (ini_path, &st) && st.st_size) {
        /* file present and not empty */
        g_key_file_load_from_file (mc_config->handle, ini_path, G_KEY_FILE_KEEP_COMMENTS, NULL);
    }

    mc_config->ini_path = g_strdup (ini_path);
    return mc_config;
}
Exemple #10
0
static struct attr_handle_s *
_alloc_attr_handle(const gchar * chunk_path)
{
	struct attr_handle_s *attr_handle = NULL;

	attr_handle = g_try_malloc0(sizeof(struct attr_handle_s));
	if (!attr_handle)
		goto error_handle;

	attr_handle->chunk_path = g_strdup(chunk_path);
	if (!attr_handle->chunk_path)
		goto error_chunk_path;

	attr_handle->attr_path = g_strdup_printf("%s.attr", chunk_path);
	if (!attr_handle->attr_path)
		goto error_attr_path;

	attr_handle->attr_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
	if (!attr_handle->attr_hash)
		goto error_hash;

	attr_handle->attr_file_des = -1;
	attr_handle->chunk_file_des = -1;
	return attr_handle;

error_hash:
	g_free(attr_handle->attr_path);
error_attr_path:
	g_free(attr_handle->chunk_path);
error_chunk_path:
	g_free(attr_handle);
error_handle:
	return NULL;
}
Exemple #11
0
struct http_put_dest_s *
http_put_add_dest(struct http_put_s *p, const char *url, gpointer u)
{
	g_assert(p != NULL);
	g_assert(p->state == HTTP_WHOLE_BEGIN);
	g_assert(url != NULL);
	g_assert(u != NULL);

	struct http_put_dest_s *dest = g_try_malloc0(sizeof(struct http_put_dest_s));
	dest->http_put = p;
	dest->url = g_strdup(url);
	dest->handle = NULL;
	dest->user_data = u;
	dest->headers = NULL;
	dest->curl_headers = NULL;
	dest->response_headers = g_hash_table_new_full (g_str_hash, g_str_equal,
			g_free, g_free);
	dest->bytes_sent = 0;
	dest->http_code = 0;
	dest->state = HTTP_SINGLE_BEGIN;

	p->dests = g_slist_append(p->dests, dest);

	return dest;
}
Exemple #12
0
static int init(struct sr_output *o)
{
	struct context *ctx;
	struct sr_probe *probe;
	GSList *l;

	sr_spew("Initializing output module.");

	if (!o || !o->sdi)
		return SR_ERR_ARG;

	if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
		sr_err("Output module context malloc failed.");
		return SR_ERR_MALLOC;
	}
	o->internal = ctx;

	/* Get the number of probes and their names. */
	ctx->probelist = g_ptr_array_new();
	for (l = o->sdi->probes; l; l = l->next) {
		probe = l->data;
		if (!probe || !probe->enabled)
			continue;
		g_ptr_array_add(ctx->probelist, probe->name);
		ctx->num_enabled_probes++;
	}

	return SR_OK;
}
Exemple #13
0
/**
 * Add a datafeed callback to the current session.
 *
 * @param cb Function to call when a chunk of data is received.
 *           Must not be NULL.
 * @param cb_data Opaque pointer passed in by the caller.
 *
 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 */
SR_API int sr_session_datafeed_callback_add(sr_datafeed_callback_t cb, void *cb_data)
{
	struct datafeed_callback *cb_struct;

	if (!session) {
		sr_err("%s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	if (!cb) {
		sr_err("%s: cb was NULL", __func__);
		return SR_ERR_ARG;
	}

	if (!(cb_struct = g_try_malloc0(sizeof(struct datafeed_callback))))
		return SR_ERR_MALLOC;

	cb_struct->cb = cb;
	cb_struct->cb_data = cb_data;

	session->datafeed_callbacks =
	    g_slist_append(session->datafeed_callbacks, cb_struct);

	return SR_OK;
}
Exemple #14
0
/**
 * Allocate memory for image display view structure and initialize it with
 * correct values.
 *
 * \return pointer to image display specific data
 */
ViewImageDisplay* view_idv_create(ViewGeneric *parent) {
	const ConfigStorage* conf;
	ViewImageDisplay *result = NULL;

	ASSERT( NULL != parent );

	if ( NULL == ( result = (ViewImageDisplay*) g_try_malloc0(sizeof(ViewImageDisplay))) ) {
		ERROR_SET(ERROR.MEMORY_FAILURE);
		return result;
	}

	result->dimension.x = 0;
	result->dimension.y = 0;
	result->view_buffer = NULL;

	// either get parameters for zooming from configuration or get default if it
	// is not present
	conf = config_get();
	if ( NULL == conf ) {
		ERROR_LOG();
		result->zoom_factor = 1.0;
		result->zoom_type = ZOOM_FIT_CUSTOM;
		result->pan_percentage = VIEW_PAN_PERCENTAGE;
	} else {
		result->zoom_factor = conf->zoom;
		result->zoom_type = conf->auto_zoom;
		result->pan_percentage = conf->pan_percentage;
	}

	return result;
}
Exemple #15
0
void *parcel_r_raw(struct parcel *p, int *len)
{
	char *ret;

	*len = parcel_r_int32(p);

	if (p->malformed || *len <= 0)
		return NULL;

	if (p->offset + *len > p->size) {
		ofono_error("%s: parcel is too small", __func__);
		p->malformed = 1;
		return NULL;
	}

	ret = g_try_malloc0(*len);
	if (ret == NULL) {
		ofono_error("%s: out of memory (%d bytes)", __func__, *len);
		return NULL;
	}

	memcpy(ret, p->data + p->offset, *len);
	p->offset += *len;

	return ret;
}
Exemple #16
0
/* This function reads the MAD2 sector */
static int mifare_read_MAD2(void *data)
{
	struct mifare_cookie *mf_ck = data;
	int err = 0;

	DBG("");

	/* As auth is ok, allocate Mifare Access Directory v1 */
	mf_ck->mad_2 = g_try_malloc0(STD_SECTOR_SIZE);
	if (!mf_ck->mad_2) {
		near_error("Memory allocation failed (MAD2)");
		err = -ENOMEM;
		goto out_err;
	}

	err = mifare_read_sector(data,
			(uint8_t *) mf_ck->mad_2,
			(int) STD_SECTOR_SIZE,
			MAD2_SECTOR,			/* sector 0x10 */
			WITH_TRAILER,			/* Want Trailer */
			read_MAD2_complete);

	if (err < 0)
		goto out_err;
	return err;

out_err:
	return mifare_release(err, mf_ck);
}
Exemple #17
0
static int
grant_client_access (struct rdma_cm_id *client, void *mem, size_t mem_size, guint type)
{
    struct kiro_connection_context *ctx = (struct kiro_connection_context *) (client->context);
    ctx->rdma_mr = (struct kiro_rdma_mem *)g_try_malloc0 (sizeof (struct kiro_rdma_mem));

    if (!ctx->rdma_mr) {
        g_critical ("Failed to allocate RDMA Memory Container: %s", strerror (errno));
        return -1;
    }

    ctx->rdma_mr->mem = mem;
    ctx->rdma_mr->size = mem_size;
    ctx->rdma_mr->mr = rdma_reg_read (client, ctx->rdma_mr->mem, ctx->rdma_mr->size);

    if (!ctx->rdma_mr->mr) {
        g_critical ("Failed to register RDMA Memory Region: %s", strerror (errno));
        kiro_destroy_rdma_memory (ctx->rdma_mr);
        return -1;
    }

    struct kiro_ctrl_msg *msg = (struct kiro_ctrl_msg *) (ctx->cf_mr_send->mem);

    msg->msg_type = type;
    msg->peer_mri = * (ctx->rdma_mr->mr);

    if (!send_msg (client, ctx->cf_mr_send)) {
        g_warning ("Failure while trying to post SEND: %s", strerror (errno));
        kiro_destroy_rdma_memory (ctx->rdma_mr);
        return -1;
    }

    g_debug ("RDMA MRI sent to client");
    return 0;
}
Exemple #18
0
static int init_known_adapters(int ctl)
{
	struct hci_dev_list_req *dl;
	struct hci_dev_req *dr;
	int i, err;

	dl = g_try_malloc0(HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t));
	if (!dl) {
		err = errno;
		error("Can't allocate devlist buffer: %s (%d)",
							strerror(err), err);
		return -err;
	}

	dl->dev_num = HCI_MAX_DEV;
	dr = dl->dev_req;

	if (ioctl(ctl, HCIGETDEVLIST, (void *) dl) < 0) {
		err = errno;
		error("Can't get device list: %s (%d)",
							strerror(err), err);
		g_free(dl);
		return -err;
	}

	for (i = 0; i < dl->dev_num; i++, dr++) {
		device_event(HCI_DEV_REG, dr->dev_id);

		if (hci_test_bit(HCI_UP, &dr->dev_opt))
			device_event(HCI_DEV_UP, dr->dev_id);
	}

	g_free(dl);
	return 0;
}
Exemple #19
0
/*****************************************************************************
 * neardal_tag_prv_add: add new NFC tag, initialize DBus Proxy connection,
 * register tag signal
 ****************************************************************************/
errorCode_t neardal_tag_prv_add(gchar *tagName, void *parent)
{
	errorCode_t	err		= NEARDAL_ERROR_NO_MEMORY;
	TagProp		*tagProp	= NULL;
	AdpProp		*adpProp	= parent;

	NEARDAL_ASSERT_RET((tagName != NULL) && (parent != NULL)
			   , NEARDAL_ERROR_INVALID_PARAMETER);

	NEARDAL_TRACEF("Adding tag:%s\n", tagName);
	tagProp = g_try_malloc0(sizeof(TagProp));
	if (tagProp == NULL)
		goto error;

	tagProp->name	= g_strdup(tagName);
	tagProp->parent	= adpProp;

	adpProp->tagList = g_list_prepend(adpProp->tagList, tagProp);
	err = neardal_tag_prv_init(tagProp);

	NEARDAL_TRACEF("NEARDAL LIB tagList contains %d elements\n",
		      g_list_length(adpProp->tagList));

	return err;

error:
	if (tagProp->name != NULL)
		g_free(tagProp->name);
	if (tagProp != NULL)
		g_free(tagProp);

	return err;
}
Exemple #20
0
static int hw_init(const char *devinfo)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;
	int devcnt = 0;

	/* Avoid compiler warnings. */
	(void)devinfo;

	if (libusb_init(&genericdmm_usb_context) != 0) {
		sr_err("genericdmm: Failed to initialize USB.");
		return 0;
	}

	if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
		sr_err("genericdmm: ctx malloc failed.");
		return 0;
	}

	devcnt = g_slist_length(genericdmm_dev_insts);
	if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, "Generic DMM",
			NULL, NULL))) {
		sr_err("genericdmm: sr_dev_inst_new returned NULL.");
		return 0;
	}
	sdi->priv = ctx;
	genericdmm_dev_insts = g_slist_append(genericdmm_dev_insts, sdi);

	/* Always initialized just one device instance. */
	return 0;
}
Exemple #21
0
static int create_search_context(struct search_context **ctxt,
				const bdaddr_t *src, const bdaddr_t *dst,
				uuid_t *uuid)
{
	sdp_session_t *s;
	GIOChannel *chan;

	if (!ctxt)
		return -EINVAL;

	s = get_sdp_session(src, dst);
	if (!s)
		return -errno;

	*ctxt = g_try_malloc0(sizeof(struct search_context));
	if (!*ctxt) {
		sdp_close(s);
		return -ENOMEM;
	}

	bacpy(&(*ctxt)->src, src);
	bacpy(&(*ctxt)->dst, dst);
	(*ctxt)->session = s;
	(*ctxt)->uuid = *uuid;

	chan = g_io_channel_unix_new(sdp_get_socket(s));
	(*ctxt)->io_id = g_io_add_watch(chan,
				G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
				connect_watch, *ctxt);
	g_io_channel_unref(chan);

	return 0;
}
Exemple #22
0
/*****************************************************************************
 * neardal_dev_prv_add: add new NFC device, initialize DBus Proxy connection,
 * register dev signal
 ****************************************************************************/
errorCode_t neardal_dev_prv_add(gchar *devName, void *parent)
{
	errorCode_t	err		= NEARDAL_ERROR_NO_MEMORY;
	DevProp		*devProp	= NULL;
	AdpProp		*adpProp	= parent;

	NEARDAL_ASSERT_RET( ((adpProp != NULL) && (devName != NULL))
			  , NEARDAL_ERROR_INVALID_PARAMETER);

	NEARDAL_TRACEF("Adding dev:%s\n", devName);
	devProp = g_try_malloc0(sizeof(DevProp));
	if (devProp == NULL)
		goto error;

	devProp->name	= g_strdup(devName);
	devProp->parent	= adpProp;

	adpProp->devList = g_list_prepend(adpProp->devList, devProp);

	NEARDAL_TRACEF("NEARDAL LIB devList contains %d elements\n",
		      g_list_length(adpProp->devList));

	return NEARDAL_SUCCESS;

error:
	if (devProp->name != NULL)
		g_free(devProp->name);
	if (devProp != NULL)
		g_free(devProp);

	return err;
}
Exemple #23
0
static void extract_ssid(DBusMessageIter *value,
					struct supplicant_result *result)
{
	DBusMessageIter array;
	unsigned char *ssid;
	int ssid_len, i;

	dbus_message_iter_recurse(value, &array);
	dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);

	if (ssid_len < 1)
		return;

	if (ssid[0] == '\0')
		return;

	result->ssid = g_try_malloc(ssid_len);
	if (result->ssid == NULL)
		return;

	memcpy(result->ssid, ssid, ssid_len);
	result->ssid_len = ssid_len;

	result->name = g_try_malloc0(ssid_len + 1);
	if (result->name == NULL)
		return;

	for (i = 0; i < ssid_len; i++) {
		if (g_ascii_isprint(ssid[i]))
			result->name[i] = ssid[i];
		else
			result->name[i] = ' ';
	}
}
Exemple #24
0
/**
* Run user selection loop. Asks for usename and if its longer than a character (newline marker)
* that user is attempted to be loaded. If failed, username is asked again.
*/
void run_user_loop() {
	gboolean loop_user = TRUE;
	
	// Allocate buffer
	gchar* user = g_try_malloc0(USERNAME_MAX_CHAR);
	
	// Selection loop
	while(loop_user) {
		g_print("Give username whose tests to run (max. %d chars) or quit (q): ",USERNAME_MAX_CHAR-1);
	
		// Get until newline
		user = fgets(user,USERNAME_MAX_CHAR,stdin);
		
		// Replace newline
		if(user[strlen(user)-1] == '\n') user[strlen(user)-1]= '\0';
		
		// Contains only 1 character or less
		if(strlen(user) < 1) {
			g_print("Empty username given.\n");
			memset(user,'\0',USERNAME_MAX_CHAR);
		}
		// Quitting
		else if (g_strcmp0("quit",user) == 0 || g_strcmp0("q",user) == 0) {
			g_free(user);
			return;
		}
		else {
			if(run_test_selection(user)) loop_user = FALSE;
		}
	}
	g_free(user);
}
Exemple #25
0
char*
girara_get_home_directory(const char* user)
{
  if (user == NULL || g_strcmp0(user, g_get_user_name()) == 0) {
    return g_strdup(g_get_home_dir());
  }

  // XXX: The following code is very unportable.
  struct passwd pwd;
  struct passwd* result = NULL;
#ifdef _SC_GETPW_R_SIZE_MAX
  int bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
  if (bufsize < 0) {
    bufsize = 4096;
  }
#else
  int bufsize = 4096;
#endif

  char* buffer = g_try_malloc0(sizeof(char) * bufsize);
  if (buffer == NULL) {
    return NULL;
  }

  getpwnam_r(user, &pwd, buffer, bufsize, &result);
  if (result == NULL) {
    g_free(buffer);
    return NULL;
  }

  char* dir = g_strdup(pwd.pw_dir);
  g_free(buffer);
  return dir;
}
Exemple #26
0
static struct wifi_sc *decode_from_tlv(const uint8_t *tlv_msg, int length)
{
	struct wifi_sc *wsc;
	uint16_t attr, len;
	uint8_t *bt;
	int pos;
	DEid id;

	if (tlv_msg == NULL || length == 0)
		return NULL;

	wsc = g_try_malloc0(sizeof(struct wifi_sc));
	if (wsc == NULL)
		return NULL;

	pos = 0;
	while (pos < length) {
		pos += get_2b_from_tlv(tlv_msg+pos, &attr);
		pos += get_2b_from_tlv(tlv_msg+pos, &len);

		if (len > length - pos)
			goto error;

		id = get_de_id(attr);
		if (id == DE_MAX) {
			pos += len;
			continue;
		}

		if (is_de_length_fine(id, len) == FALSE)
			goto error;

		switch (id) {
		case DE_AUTHENTICATION_TYPE:
			break;
		case DE_NETWORK_KEY:
			wsc->passphrase = get_string_from_tlv(tlv_msg+pos,
									len);
			break;
		case DE_SSID:
			bt = get_byte_array_from_tlv(tlv_msg+pos, len);
			wsc->ssid = get_hexstr_from_byte_array(bt, len);
			g_free(bt);

			break;
		case DE_MAX:
			/* Falling back. Should never happen though. */
		default:
			break;
		}

		pos += len;
	}

	return wsc;

error:
	free_wifi_sc(wsc);
	return NULL;
}
Exemple #27
0
/**
 * Convert a numeric time(ns) value to the "natural" string representation
 * of its period.
 *
 * E.g. a value of 3000000 would be converted to "3 ms", 20000 to "20 us".
 *
 * @param time The time in ns.
 *
 * @return A g_try_malloc()ed string representation of the time value,
 *         or NULL upon errors. The caller is responsible to g_free() the
 *         memory.
 */
SR_API char *sr_time_string(uint64_t time)
{
    char *o;
    int r;

    /* Allocate enough for a uint64_t as string + " ms". */
    if (!(o = g_try_malloc0(30 + 1))) {
        sr_err("%s: o malloc failed", __func__);
        return NULL;
    }

    if (time >= 1000000000)
        r = snprintf(o, 30, "%" PRIu64 " s", time / 1000000000);
    else if (time >= 1000000)
        r = snprintf(o, 30, "%" PRIu64 " ms", time / 1000000);
    else if (time >= 1000)
        r = snprintf(o, 30, "%" PRIu64 " us", time / 1000);
    else
        r = snprintf(o, 30, "%" PRIu64 " ns", time);

    if (r < 0) {
        /* Something went wrong... */
        g_free(o);
        return NULL;
    }

    return o;
}
Exemple #28
0
static guint bluetooth_connect(const char *source, const char *destination,
				const char *service, uint16_t port,
				obc_transport_func func, void *user_data)
{
	struct bluetooth_session *session;
	static guint id = 0;

	DBG("src %s dest %s service %s port %u",
				source, destination, service, port);

	if (destination == NULL)
		return 0;

	session = g_try_malloc0(sizeof(*session));
	if (session == NULL)
		return 0;

	session->id = ++id;
	session->func = func;
	session->port = port;
	session->user_data = user_data;

	str2ba(destination, &session->dst);
	str2ba(source, &session->src);

	if (session_connect(session) < 0) {
		g_free(session);
		return 0;
	}

	session->service = g_strdup(service);
	sessions = g_slist_prepend(sessions, session);

	return session->id;
}
static void handle_uhid_output(struct hid_device *dev,
						struct uhid_output_req *output)
{
	int fd, i;
	uint8_t *req = NULL;
	uint8_t req_size = 0;

	if (!(dev->ctrl_io))
		return;

	req_size = 1 + (output->size / 2);
	req = g_try_malloc0(req_size);
	if (!req)
		return;

	req[0] = HID_MSG_SET_REPORT | output->rtype;
	for (i = 0; i < (req_size - 1); i++)
		sscanf((char *) &(output->data)[i * 2], "%hhx", &req[1 + i]);

	fd = g_io_channel_unix_get_fd(dev->ctrl_io);

	if (write(fd, req, req_size) < 0)
		error("error writing set_report: %s (%d)",
						strerror(errno), errno);

	g_free(req);
}
Exemple #30
0
static int ndef_register(const char *sender, const char *path,
						const char *record_type)
{
	struct near_ndef_agent *agent;

	DBG("%s registers path %s for %s", sender, path, record_type);

	if (g_hash_table_lookup(ndef_app_hash, record_type))
		return -EEXIST;

	agent = g_try_malloc0(sizeof(struct near_ndef_agent));
	if (!agent)
		return -ENOMEM;

	agent->sender = g_strdup(sender);
	agent->path = g_strdup(path);
	agent->record_type = g_strdup(record_type);

	if (!agent->sender || !agent->path ||
	    !agent->record_type) {
		g_free(agent);
		return -ENOMEM;
	}

	agent->watch = g_dbus_add_disconnect_watch(connection, sender,
							ndef_agent_disconnect,
							agent, NULL);
	g_hash_table_insert(ndef_app_hash, agent->record_type, agent);

	return 0;
}