/* LQR_PUBLIC */
LqrRetVal
lqr_carver_bias_add_area(LqrCarver *r, gdouble *buffer, gint bias_factor, gint width, gint height, gint x_off,
                         gint y_off)
{
    gint x, y;
    gint xt, yt;
    gint wt, ht;
    gint x0, y0, x1, y1, x2, y2;
    gfloat bias;

    LQR_CATCH_CANC(r);

    if (bias_factor == 0) {
        return LQR_OK;
    }

    if ((r->w != r->w0) || (r->w_start != r->w0) || (r->h != r->h0) || (r->h_start != r->h0)) {
        LQR_CATCH(lqr_carver_flatten(r));
    }

    if (r->nrg_active == FALSE) {
        LQR_CATCH(lqr_carver_init_energy_related(r));
    }

    if (r->bias == NULL) {
        LQR_CATCH_MEM(r->bias = g_try_new0(gfloat, r->w * r->h));
    }

    wt = r->transposed ? r->h : r->w;
    ht = r->transposed ? r->w : r->h;

    x0 = MIN(0, x_off);
    y0 = MIN(0, y_off);
    x1 = MAX(0, x_off);
    y1 = MAX(0, y_off);
    x2 = MIN(wt, width + x_off);
    y2 = MIN(ht, height + y_off);

    for (y = 0; y < y2 - y1; y++) {
        for (x = 0; x < x2 - x1; x++) {
            bias = (gfloat) ((gdouble) bias_factor * buffer[(y - y0) * width + (x - x0)] / 2);

            xt = r->transposed ? y : x;
            yt = r->transposed ? x : y;

            r->bias[(yt + y1) * r->w0 + (xt + x1)] += bias;
        }
    }

    r->nrg_uptodate = FALSE;

    return LQR_OK;
}
Пример #2
0
GAtHDLC *g_at_hdlc_new_from_io(GAtIO *io)
{
	GAtHDLC *hdlc;
	unsigned char *buf;

	if (io == NULL)
		return NULL;

	hdlc = g_try_new0(GAtHDLC, 1);
	if (hdlc == NULL)
		return NULL;

	hdlc->ref_count = 1;
	hdlc->decode_fcs = HDLC_INITFCS;
	hdlc->decode_offset = 0;
	hdlc->decode_escape = FALSE;

	hdlc->xmit_accm[0] = ~0U;
	hdlc->xmit_accm[3] = 0x60000000; /* 0x7d, 0x7e */
	hdlc->recv_accm = ~0U;

	hdlc->write_buffer = ring_buffer_new(BUFFER_SIZE * 2);
	if (!hdlc->write_buffer)
		goto error;

	/* Write an initial 0x7e as wakeup character */
	buf = ring_buffer_write_ptr(hdlc->write_buffer, 0);
	*buf = HDLC_FLAG;
	ring_buffer_write_advance(hdlc->write_buffer, 1);

	hdlc->decode_buffer = g_try_malloc(BUFFER_SIZE * 2);
	if (!hdlc->decode_buffer)
		goto error;

	hdlc->record_fd = -1;

	hdlc->io = g_at_io_ref(io);
	g_at_io_set_read_handler(hdlc->io, new_bytes, hdlc);

	return hdlc;

error:
	if (hdlc->write_buffer)
		ring_buffer_free(hdlc->write_buffer);

	if (hdlc->decode_buffer)
		g_free(hdlc->decode_buffer);

	g_free(hdlc);

	return NULL;
}
Пример #3
0
int
tty_try_alloc_color_pair2 (const char *fg, const char *bg, const char *attrs,
                           gboolean is_temp_color)
{
    gchar *color_pair;
    tty_color_pair_t *mc_color_pair;
    int ifg, ibg, attr;

    if (fg == NULL || !strcmp (fg, "base"))
        fg = tty_color_defaults__fg;
    if (bg == NULL || !strcmp (bg, "base"))
        bg = tty_color_defaults__bg;
    if (attrs == NULL || !strcmp (attrs, "base"))
        attrs = tty_color_defaults__attrs;

    ifg = tty_color_get_index_by_name (fg);
    ibg = tty_color_get_index_by_name (bg);
    attr = tty_attr_get_bits (attrs);

    color_pair = g_strdup_printf ("%d.%d.%d", ifg, ibg, attr);
    if (color_pair == NULL)
        return 0;

    mc_color_pair =
        (tty_color_pair_t *) g_hash_table_lookup (mc_tty_color__hashtable, (gpointer) color_pair);

    if (mc_color_pair != NULL)
    {
        g_free (color_pair);
        return mc_color_pair->pair_index;
    }

    mc_color_pair = g_try_new0 (tty_color_pair_t, 1);
    if (mc_color_pair == NULL)
    {
        g_free (color_pair);
        return 0;
    }

    mc_color_pair->is_temp = is_temp_color;
    mc_color_pair->ifg = ifg;
    mc_color_pair->ibg = ibg;
    mc_color_pair->attr = attr;
    mc_color_pair->pair_index = tty_color_get_next__color_pair_number ();

    tty_color_try_alloc_pair_lib (mc_color_pair);

    g_hash_table_insert (mc_tty_color__hashtable, (gpointer) color_pair, (gpointer) mc_color_pair);

    return mc_color_pair->pair_index;
}
Пример #4
0
static int sqlfs_open(const char *path, struct fuse_file_info *fi)
{
  int err = 0;

  GError *terr = NULL;
  struct sqlfs_object *object = find_object(path, &terr);
  if (terr != NULL && terr->code == EENOTFOUND) {
    err = -ENOENT;
  }
  
  if ((fi->flags & O_ACCMODE) == O_RDONLY) {
    if (fi->flags & O_CREAT) {
      err = sqlfs_mknod(path, 07777 | S_IFREG, 0);
    }
  } else {
    if ((fi->flags & O_ACCMODE) == O_RDWR
	|| (fi->flags & O_ACCMODE) == O_WRONLY) {
      if ((fi->flags & O_EXCL) && object->object_id)
	err = -EACCES;
    }
    else {
      err = -EIO;
    }
  }
  
  if (!err) {
    // FIXME: Не надёжная генерация уникальных значений
    fi->fh = object->object_id + g_get_monotonic_time();
    
    char *def = fetch_object_text(path, &terr);
    if (def != NULL) {
      sqlfs_file_t *fsfile = g_try_new0(sqlfs_file_t, 1);
      uint64_t *pfh = g_malloc0(sizeof(uint64_t));
      *pfh = fi->fh;
      if (def) {
	fsfile->buffer = g_strdup(def);
      }

      g_hash_table_insert(cache.open_table, pfh, fsfile);
    }

    if (object != NULL)
      free_sqlfs_object(object);
  }

  if (terr != NULL)
    g_error_free(terr);
  
  return err;
}
Пример #5
0
ut_Timer* ut_Timer_new(void* userdata, ut_TimerCallback* cb, GError** error)
{
  ut_Timer* self = g_try_new0(ut_Timer, 1);
  if (G_UNLIKELY(!self)) {
    if (error) *error = gx_error_no_memory;
    return NULL;
  }
  self->timer = new_nothrow MyTimer(userdata, cb);
  if (G_UNLIKELY(!(self->timer))) {
    g_free(self);
    if (error) *error = gx_error_no_memory;
    return NULL;
  }
  return self;
}
Пример #6
0
EXTERN_C sa_Sensor_mark* sa_Sensor_mark_new(LogDb* log, GError** error)
{
  sa_Sensor_mark* self = g_try_new0(sa_Sensor_mark, 1);
  if (G_UNLIKELY(!self)) {
    if (error) *error = gx_error_no_memory;
    return NULL;
  }
  self->log = log;
  self->timer = ut_Timer_new(self, &timerCallback, error);
  if (!self->timer) {
    sa_Sensor_mark_destroy(self);
    return NULL;
  }
  return self;
}
Пример #7
0
static void
mc_skin_color_set_default_for_terminal (mc_skin_t * mc_skin)
{
    mc_skin_color_t *mc_skin_color;
    mc_skin_color = g_try_new0 (mc_skin_color_t, 1);
    if (mc_skin_color != NULL)
    {
        mc_skin_color->fgcolor = g_strdup ("default");
        mc_skin_color->bgcolor = g_strdup ("default");
        mc_skin_color->attrs = NULL;
        mc_skin_color->pair_index =
            tty_try_alloc_color_pair2 (mc_skin_color->fgcolor, mc_skin_color->bgcolor,
                                       mc_skin_color->attrs, FALSE);
        mc_skin_color_add_to_hash (mc_skin, "skin", "terminal_default_color", mc_skin_color);
    }
}
Пример #8
0
mongo_sync_connection *
test_make_fake_sync_conn (gint fd, gboolean slaveok)
{
  mongo_sync_connection *c;

  c = g_try_new0 (mongo_sync_connection, 1);
  if (!c)
    return NULL;

  c->super.fd = fd;
  c->slaveok = slaveok;
  c->safe_mode = FALSE;
  c->auto_reconnect = FALSE;
  c->max_insert_size = MONGO_SYNC_DEFAULT_MAX_INSERT_SIZE;

  return c;
}
Пример #9
0
GAtRawIP *g_at_rawip_new_from_io(GAtIO *io)
{
	GAtRawIP *rawip;

	rawip = g_try_new0(GAtRawIP, 1);
	if (rawip == NULL)
		return NULL;

	rawip->ref_count = 1;

	rawip->write_buffer = NULL;
	rawip->tun_write_buffer = NULL;

	rawip->io = g_at_io_ref(io);

	return rawip;
}
Пример #10
0
static GRilIO *create_io(GIOChannel *channel, GIOFlags flags)
{
	GRilIO *io;

	if (channel == NULL)
		return NULL;

	io = g_try_new0(GRilIO, 1);
	if (io == NULL)
		return io;

	io->ref_count = 1;
	io->debugf = NULL;

	if (flags & G_IO_FLAG_NONBLOCK) {
		io->max_read_attempts = 3;
		io->use_write_watch = TRUE;
	} else {
		io->max_read_attempts = 1;
		io->use_write_watch = FALSE;
	}

	io->buf = ring_buffer_new(8192);

	if (!io->buf)
		goto error;

	if (!g_ril_util_setup_io(channel, flags))
		goto error;

	io->channel = channel;
	io->read_watch = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT,
				G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
				received_data, io,
				read_watcher_destroy_notify);

	return io;

error:
	if (io->buf)
		ring_buffer_free(io->buf);

	g_free(io);

	return NULL;
}
Пример #11
0
/**
 * Create a QEMUSizedBuffer
 * This type of buffer uses scatter-gather lists internally and
 * can grow to any size. Any data array in the scatter-gather list
 * can hold different amount of bytes.
 *
 * @buffer: Optional buffer to copy into the QSB
 * @len: size of initial buffer; if @buffer is given, buffer must
 *       hold at least len bytes
 *
 * Returns a pointer to a QEMUSizedBuffer or NULL on allocation failure
 */
QEMUSizedBuffer *qsb_create(const uint8_t *buffer, size_t len)
{
    QEMUSizedBuffer *qsb;
    size_t alloc_len, num_chunks, i, to_copy;
    size_t chunk_size = (len > QSB_MAX_CHUNK_SIZE)
                        ? QSB_MAX_CHUNK_SIZE
                        : QSB_CHUNK_SIZE;

    num_chunks = DIV_ROUND_UP(len ? len : QSB_CHUNK_SIZE, chunk_size);
    alloc_len = num_chunks * chunk_size;

    qsb = g_try_new0(QEMUSizedBuffer, 1);
    if (!qsb) {
        return NULL;
    }

    qsb->iov = g_try_new0(struct iovec, num_chunks);
    if (!qsb->iov) {
        g_free(qsb);
        return NULL;
    }

    qsb->n_iov = num_chunks;

    for (i = 0; i < num_chunks; i++) {
        qsb->iov[i].iov_base = g_try_malloc0(chunk_size);
        if (!qsb->iov[i].iov_base) {
            /* qsb_free is safe since g_free can cope with NULL */
            qsb_free(qsb);
            return NULL;
        }

        qsb->iov[i].iov_len = chunk_size;
        if (buffer) {
            to_copy = (len - qsb->used) > chunk_size
                      ? chunk_size : (len - qsb->used);
            memcpy(qsb->iov[i].iov_base, &buffer[qsb->used], to_copy);
            qsb->used += to_copy;
        }
    }

    qsb->size = alloc_len;

    return qsb;
}
Пример #12
0
/**
 * Check the correctness of a layout string.
 * @param layout The layout string as stored in the config files
 *        "type1;left1;right1;top1;bottom1;type2; ... "
 * @return LAYOUT_GOOD if the layout is valid, LAYOUT_BAD if the layout is invalid.
 *
 * A layout is invalid if it refers to a non-existent view type or if there is something wrong
 * with the coordinates (e.g. left > right).
 */
gboolean sat_pref_layout_check(const gchar * layout)
{
    gchar         **buffv;
    guint           length, nviews;
    gint           *grid;
    guint           i;
    gboolean        error = FALSE;

    /* split layout string into an array of strings */
    buffv = g_strsplit(layout, ";", 0);
    length = g_strv_length(buffv);

    /* check correct number of entries */
    if ((length == 0) || (length % 5 != 0))
    {
        error |= TRUE;
    }

    nviews = length / 5;
    grid = g_try_new0(gint, length);

    /* convert string to array of integers */
    for (i = 0; i < length; i++)
    {
        grid[i] = (gint) g_ascii_strtoll(buffv[i], NULL, 0);
    }

    /* check each view record */
    for (i = 0; i < nviews; i++)
    {

        if ((grid[5 * i] >= GTK_SAT_MOD_VIEW_NUM) ||    /* view type within range */
            (grid[5 * i + 1] >= grid[5 * i + 2]) ||     /* left < right */
            (grid[5 * i + 3] >= grid[5 * i + 4]))
        {                       /* top < bottom */
            error |= TRUE;
        }

    }

    g_free(grid);
    g_strfreev(buffv);

    return (error ? LAYOUT_BAD : LAYOUT_GOOD);
}
Пример #13
0
GIOChannel *g_at_mux_create_channel(GAtMux *mux)
{
	GAtMuxChannel *mux_channel;
	GIOChannel *channel;
	int i;

	for (i = 0; i < MAX_CHANNELS; i++) {
		if (mux->dlcs[i] == NULL)
			break;
	}

	if (i == MAX_CHANNELS)
		return NULL;

	mux_channel = g_try_new0(GAtMuxChannel, 1);
	if (mux_channel == NULL)
		return NULL;

	if (mux->driver->open_dlc)
		mux->driver->open_dlc(mux, i+1);

	channel = (GIOChannel *) mux_channel;

	g_io_channel_init(channel);
	channel->close_on_unref = TRUE;
	channel->funcs = &channel_funcs;

	channel->is_seekable = FALSE;
	channel->is_readable = TRUE;
	channel->is_writeable = TRUE;

	channel->do_encode = FALSE;

	mux_channel->mux = mux;
	mux_channel->dlc = i+1;
	mux_channel->buffer = ring_buffer_new(MUX_CHANNEL_BUFFER_SIZE);
	mux_channel->throttled = FALSE;

	mux->dlcs[i] = mux_channel;

	debug(mux, "created channel %p, dlc: %d", channel, i+1);

	return channel;
}
Пример #14
0
Qcow2Cache *qcow2_cache_create(BlockDriverState *bs, int num_tables)
{
    BDRVQcowState *s = bs->opaque;
    Qcow2Cache *c;

    c = g_new0(Qcow2Cache, 1);
    c->size = num_tables;
    c->entries = g_try_new0(Qcow2CachedTable, num_tables);
    c->table_array = qemu_try_blockalign(bs->file,
                                         (size_t) num_tables * s->cluster_size);

    if (!c->entries || !c->table_array) {
        qemu_vfree(c->table_array);
        g_free(c->entries);
        g_free(c);
        c = NULL;
    }

    return c;
}
LqrRetVal
lqr_carver_rigmask_init(LqrCarver *r)
{
    /* gint y, x; */

    LQR_CATCH_CANC(r);

    LQR_CATCH_F(r->active);

    LQR_CATCH_MEM(r->rigidity_mask = g_try_new0(gfloat, r->w0 * r->h0));

#if 0
    for (y = 0; y < r->h0; y++) {
        for (x = 0; x < r->w0; x++) {
            r->rigidity_mask[y * r->w0 + x] = 1;
        }
    }
#endif

    return LQR_OK;
}
extern "C" ut_Immediate* ut_Immediate_new(void* userdata, ut_ImmediateCallback* cb, 
					  GError** error)
{
  ut_Immediate* self = g_try_new0(ut_Immediate, 1);
  if (G_UNLIKELY(!self)) {
    if (error) *error = gx_error_no_memory;
    return NULL;
  }
  self->userdata = userdata;
  self->cb = cb;

  TRAPD(errCode, self->ao = CImmediateAo::NewL(*self));
  if (G_UNLIKELY(errCode)) {
    g_free(self);
    if (error) 
      *error = make_error(errCode, "failed to create native immediate instance");
    return NULL;
  }

  return self;
}
Пример #17
0
GIsiClient *g_isi_client_create(GIsiModem *modem, uint8_t resource)
{
	GIsiClient *client;

	if (modem == NULL) {
		errno = EINVAL;
		return NULL;
	}

	client  = g_try_new0(GIsiClient, 1);
	if (client == NULL) {
		errno = ENOMEM;
		return NULL;
	}

	client->timeout = G_ISI_CLIENT_DEFAULT_TIMEOUT;
	client->resource = resource;
	client->modem = modem;

	return client;
}
Пример #18
0
GAtMux *g_at_mux_new(GIOChannel *channel, const GAtMuxDriver *driver)
{
	GAtMux *mux;

	if (channel == NULL)
		return NULL;

	mux = g_try_new0(GAtMux, 1);
	if (mux == NULL)
		return NULL;

	mux->ref_count = 1;
	mux->driver = driver;
	mux->shutdown = TRUE;

	mux->channel = channel;
	g_io_channel_ref(channel);

	g_io_channel_set_close_on_unref(channel, TRUE);

	return mux;
}
Пример #19
0
Файл: givimage.c Проект: dov/giv
GivImage *giv_image_new_full(GivImageType img_type,
                             int width,
                             int row_stride,
                             int height,
                             int frame_stride,
                             int rank,
                             int depth)
{
    GivImage *img = g_new0(GivImage, 1);
    img->rank = rank;
    img->ref_count = 1;
    img->img_type = img_type;
    img->width = width;
    img->row_stride = row_stride;
    img->frame_stride = frame_stride;
    img->height= height;
    if (depth < 1)
        depth = 1;
    img->depth = depth;
    int buf_size = frame_stride * depth;

    // This should probably be aligned to be faster...
    img->buf.buf = (guint8*)g_try_new0(guint8, buf_size);
    if (!img->buf.buf) {
        g_free(img);
        return NULL;
    }
          
    img->attribute_map = g_hash_table_new_full(g_str_hash,
                                               g_str_equal,
                                               g_free,
                                               g_free);
    // One bit is used for signalling one bit images. This should
    // eventually be moved into image type. By default it is off.
    img->one_bit = FALSE;
    return img;
}
Пример #20
0
static mc_skin_color_t *
mc_skin_color_get_from_ini_file (mc_skin_t * mc_skin, const gchar * group, const gchar * key)
{
    gsize items_count;
    gchar **values;
    mc_skin_color_t *mc_skin_color, *tmp;

    values = mc_config_get_string_list (mc_skin->config, group, key, &items_count);
    if (values == NULL || values[0] == NULL)
    {
        g_strfreev (values);
        return NULL;
    }

    mc_skin_color = g_try_new0 (mc_skin_color_t, 1);
    if (mc_skin_color == NULL)
    {
        g_strfreev (values);
        return NULL;
    }

    tmp = mc_skin_color_get_with_defaults (group, "_default_");
    mc_skin_color->fgcolor = (items_count > 0 && values[0][0]) ? g_strstrip (g_strdup (values[0])) :
        (tmp != NULL) ? g_strdup (tmp->fgcolor) : NULL;
    mc_skin_color->bgcolor = (items_count > 1 && values[1][0]) ? g_strstrip (g_strdup (values[1])) :
        (tmp != NULL) ? g_strdup (tmp->bgcolor) : NULL;
    mc_skin_color->attrs = (items_count > 2 && values[2][0]) ? g_strstrip (g_strdup (values[2])) :
        (tmp != NULL) ? g_strdup (tmp->attrs) : NULL;

    g_strfreev (values);

    mc_skin_color->pair_index =
        tty_try_alloc_color_pair2 (mc_skin_color->fgcolor, mc_skin_color->bgcolor,
                                   mc_skin_color->attrs, FALSE);

    return mc_skin_color;
}
Пример #21
0
static bool view_main_wifi_insert_found_ap(wifi_device_info_t *wifi_device)
{
	devpkr_gl_data_t *gdata = g_try_new0(devpkr_gl_data_t, 1);
	wifi_connection_state_e state;

	assertm_if(NULL == list, "list is NULL");

	if (gdata == NULL)
		return false;

	gdata->dev_info = wifi_device;
	if (gdata->dev_info == NULL) {
		g_free(gdata);
		return true;
	}

	wifi_ap_get_connection_state(wifi_device->ap, &state);

	if (WIFI_CONNECTION_STATE_ASSOCIATION == state ||
			WIFI_CONNECTION_STATE_CONFIGURATION == state) {
		gdata->connection_mode = ITEM_CONNECTION_MODE_CONNECTING;
		gdata->it = elm_genlist_item_append(list, &itc, gdata,
				NULL, ELM_GENLIST_ITEM_NONE, __gl_sel,
				gdata);
		view_main_state_set(ITEM_CONNECTION_MODE_CONNECTING);

		return true;
	}

	gdata->connection_mode = ITEM_CONNECTION_MODE_OFF;

	gdata->it = elm_genlist_item_append(list, &itc, gdata, NULL,
			ELM_GENLIST_ITEM_NONE, __gl_sel, gdata);

	return true;
}
Пример #22
0
static GDBusProxy *proxy_new(GDBusClient *client, const char *path,
						const char *interface)
{
	GDBusProxy *proxy;

	proxy = g_try_new0(GDBusProxy, 1);
	if (proxy == NULL)
		return NULL;

	proxy->client = client;
	proxy->obj_path = g_strdup(path);
	proxy->interface = g_strdup(interface);

	proxy->prop_list = g_hash_table_new_full(g_str_hash, g_str_equal,
							NULL, prop_entry_free);
	proxy->watch = g_dbus_add_properties_watch(client->dbus_conn,
							client->service_name,
							proxy->obj_path,
							proxy->interface,
							properties_changed,
							proxy, NULL);

	return g_dbus_proxy_ref(proxy);
}
Пример #23
0
static void
swfdec_as_array_do_sort (SwfdecAsContext *cx, SwfdecAsObject *object,
    const SortOption *options, SwfdecAsFunction *custom_function,
    const char **fields, SwfdecAsValue *ret)
{
  SortEntry *array;
  SortCollectData collect_data;
  SortCompareData compare_data;
  gint32 i, length;
  const char *var;
  SwfdecAsObject *target;
  SwfdecAsValue val;
  SortOption options_;
  gboolean descending;

  g_return_if_fail (SWFDEC_IS_AS_CONTEXT (cx));
  g_return_if_fail (SWFDEC_IS_AS_OBJECT (object));
  g_return_if_fail (options != NULL);
  g_return_if_fail (custom_function == NULL ||
      SWFDEC_IS_AS_FUNCTION (custom_function));
  g_return_if_fail (fields == NULL || fields[0] != NULL);

  length = swfdec_as_array_length (object);
  if (length == 0) {
    // special case for empty array, because g_try_new0 would return NULL
    SWFDEC_AS_VALUE_SET_OBJECT (ret, object);
    return;
  }

  if (!swfdec_as_context_try_use_mem (cx, sizeof (SortEntry) * length)) {
    SWFDEC_WARNING ("Array not sorted, too big (%i elements)", length);
    SWFDEC_AS_VALUE_SET_OBJECT (ret, object);
    return;
  }

  // FIXME: this should be different, but context's memory management is not
  // done properly yet
  array = g_try_new0 (SortEntry, length);
  if (!array) {
    SWFDEC_WARNING ("Array not sorted, too big (%i elements)", length);
    SWFDEC_AS_VALUE_SET_OBJECT (ret, object);
    goto done;
  }

  for (i = 0; i < length; i++) {
    array[i].index_ = i;
  }

  // collect values and indexes to the array
  collect_data.length = length;
  collect_data.array = array;

  swfdec_as_object_foreach (object, swfdec_as_array_foreach_sort_collect,
	&collect_data);

  // sort the array
  compare_data.context = cx;
  compare_data.fields = fields;
  compare_data.options = options;
  // if no fields, then we'll do descending here after the sort
  if (fields == NULL && options[0] & SORT_OPTION_DESCENDING) {
    descending = TRUE;
    options_ = options[0] & ~SORT_OPTION_DESCENDING;
    compare_data.options = &options_;
  } else {
    descending = FALSE;
  }
  compare_data.custom_function = custom_function;
  compare_data.equal_found = FALSE;

  swfdec_as_array_sort_array (array, length, swfdec_as_array_sort_compare,
      &compare_data);

  // check unique sort
  if (options[0] & SORT_OPTION_UNIQUESORT) {
    if (fields == NULL && custom_function != NULL) {
      // if we used custom_function for comparision, we shall now go trough the
      // sorted array and compare them using the default array sort comparision
      // and use that to decide if it's unique (no it doesn't make too much
      // sense)
      for (i = 0; i < length - 1; i++) {
	SwfdecAsValue *a = &array[i].value;
	SwfdecAsValue *b = &array[i + 1].value;
	if (swfdec_as_array_sort_compare_values (cx, a, b, 0, NULL) == 0)
	  break;
      }
      if (i < length - 1) {
	SWFDEC_AS_VALUE_SET_INT (ret, 0);
	goto done;
      }
    } else if (compare_data.equal_found) {
      SWFDEC_AS_VALUE_SET_INT (ret, 0);
      goto done;
    }
  }

  if (options[0] & SORT_OPTION_RETURNINDEXEDARRAY) {
    target = swfdec_as_array_new (cx);
    if (!target)
      goto done;
  } else {
    target = object;
  }

  for (i = 0; i < length; i++) {
    SortEntry *entry = &array[i];

    // set only the values that have new indexes
    if (!(options[0] & SORT_OPTION_RETURNINDEXEDARRAY) &&
	entry->index_ == (descending ? length - i - 1 : i))
      continue;

    var = swfdec_as_integer_to_string (cx, (descending ? length - i - 1 : i));
    if (options[0] & SORT_OPTION_RETURNINDEXEDARRAY) {
      SWFDEC_AS_VALUE_SET_INT (&val, entry->index_);
      swfdec_as_object_set_variable (target, var, &val);
    } else {
      swfdec_as_object_set_variable (target, var, &entry->value);
    }
  }

  SWFDEC_AS_VALUE_SET_OBJECT (ret, target);

done:
  g_free (array);
  swfdec_as_context_unuse_mem (cx, sizeof (SortEntry) * length);
}
Пример #24
0
/**
 * Read QTH file and add data to list store.
 * @param liststore The GtkListStore where the data should be stored.
 * @param filename The full name of the qth file.
 * @return 1 if read is successful, 0 if an error occurs.
 *
 * The function uses the gtk-sat-data infrastructure to read the qth
 * data from the specified file.
 *
 * There is a little challenge here. First, we want to read the data from
 * the .qth files and store them in the list store. To do this we use a
 * qth_t structure, which can be populated using gtk_sat_data_read_qth.
 * Then, when the configuration is finished and the user presses "OK", we
 * want to write all the data back to the .qth files. To do that, we create
 * an up-to-date qth_t data structure and pass it to the gtk_sat_data_write_qth
 * function, which will take care of updating the GKeyFile data structure and
 * writing the contents to the .qth file.
 */
static guint read_qth_file(GtkListStore * liststore, gchar * filename)
{
    GtkTreeIter     item;       /* new item added to the list store */
    qth_t          *qth;        /* qth data structure */
    gchar          *defqth;
    gboolean        is_default = FALSE;
    gchar          *fname;
    gint            dispalt;    /* displayed altitude */

    if ((qth = g_try_new0(qth_t, 1)) == NULL)
    {
        sat_log_log(SAT_LOG_LEVEL_ERROR,
                    _("%s:%d: Failed to allocate memory!\n"),
                    __FILE__, __LINE__);

        return FALSE;
    }

    /* read data from file */
    if (!qth_data_read(filename, qth))
    {
        g_free(qth);
        return FALSE;
    }

    /* calculate QRA locator */
    gint            retcode;

    qth->qra = g_malloc(7);
    retcode = longlat2locator(qth->lon, qth->lat, qth->qra, 3);

    if (retcode != RIG_OK)
    {
        sat_log_log(SAT_LOG_LEVEL_ERROR,
                    _("%s:%d: Could not convert (%.2f,%.2f) to QRA."),
                    __FILE__, __LINE__, qth->lat, qth->lon);
        qth->qra[0] = '\0';
    }
    else
    {
        qth->qra[6] = '\0';
        sat_log_log(SAT_LOG_LEVEL_DEBUG,
                    _("%s:%d: QRA locator is %s"),
                    __FILE__, __LINE__, qth->qra);
    }

    /* is this the default qth? */
    defqth = sat_cfg_get_str(SAT_CFG_STR_DEF_QTH);

    if (g_str_has_suffix(filename, defqth))
    {
        is_default = TRUE;

        sat_log_log(SAT_LOG_LEVEL_INFO,
                    _("%s:%d: This appears to be the default QTH."),
                    __FILE__, __LINE__);
    }

    g_free(defqth);

    /* check wehter we are using imperial or metric system;
       in case of imperial we have to convert altitude from
       meters to feet.
       note: the internat data are always kept in metric and
       only the displayed numbers are converted. Therefore,
       we use a dedicated var 'dispalt'
     */
    /* NO, ONLY DISPLAY WIDGETS WILL BE AFFECTED BY THIS SETTING */
    if (sat_cfg_get_bool(SAT_CFG_BOOL_USE_IMPERIAL))
    {
        dispalt = (gint) M_TO_FT(qth->alt);
    }
    else
    {
        dispalt = (gint) qth->alt;
    }

    /* strip file name; we don't need the whole path */
    fname = g_path_get_basename(filename);

    /* we now have all necessary data in the qth_t structure;
       add the data to the list store */
    gtk_list_store_append(liststore, &item);
    gtk_list_store_set(liststore, &item,
                       QTH_LIST_COL_NAME, qth->name,
                       QTH_LIST_COL_LOC, qth->loc,
                       QTH_LIST_COL_DESC, qth->desc,
                       QTH_LIST_COL_LAT, qth->lat,
                       QTH_LIST_COL_LON, qth->lon,
                       QTH_LIST_COL_ALT, dispalt,
                       QTH_LIST_COL_QRA, qth->qra,
                       QTH_LIST_COL_WX, qth->wx,
                       QTH_LIST_COL_DEF, is_default,
                       QTH_LIST_COL_TYPE, qth->type,
                       QTH_LIST_COL_GPSD_SERVER, qth->gpsd_server,
                       QTH_LIST_COL_GPSD_PORT, qth->gpsd_port, -1);

    g_free(fname);

    /* we are finished with this qth, free it */
    qth_data_free(qth);

    return TRUE;
}
Пример #25
0
static void get_uid_reply(unsigned int uid, void *user_data, int err)
{
	struct cb_data *cbd = user_data;
	connman_session_config_func_t cb = cbd->cb;
	struct policy_config *policy = cbd->data;
	const char *owner;
	struct passwd *pwd;
	struct group *grp;
	gid_t *groups = NULL;
	int nrgroups, i;

	DBG("session %p uid %d", policy->session, uid);

	if (err < 0) {
		cleanup_config(policy);
		goto err;
	}

	pwd = getpwuid((uid_t)uid);
	if (!pwd) {
		if (errno != 0)
			err = -errno;
		else
			err = -EINVAL;
		goto err;
	}

	policy->uid = g_strdup(pwd->pw_name);

	nrgroups = 0;
	getgrouplist(pwd->pw_name, pwd->pw_gid, NULL, &nrgroups);
	groups = g_try_new0(gid_t, nrgroups);
	if (!groups) {
		err = -ENOMEM;
		goto err;
	}

	err = getgrouplist(pwd->pw_name, pwd->pw_gid, groups, &nrgroups);
	if (err < 0)
		goto err;

	for (i = 0; i < nrgroups; i++) {
		grp = getgrgid(groups[i]);
		if (!grp) {
			if (errno != 0)
				err = -errno;
			else
				err = -EINVAL;
			goto err;
		}

		policy->gids = g_slist_prepend(policy->gids,
					g_strdup(grp->gr_name));
	}
	g_free(groups);

	owner = connman_session_get_owner(policy->session);

	err = connman_dbus_get_selinux_context(connection, owner,
						selinux_context_reply, cbd);
	if (err == 0) {
		/*
		 * We are able to ask for a SELinux context. Let's defer the
		 * creation of the session config until we get the answer
		 * from D-Bus.
		 */
		return;
	}

	finish_create(policy, cb, cbd->user_data);
	g_free(cbd);

	return;

err:
	failed_create(NULL, cb, cbd->user_data, err);
	g_free(cbd);
	g_free(groups);
}
Пример #26
0
GDBusClient *g_dbus_client_new_full(DBusConnection *connection,
							const char *service,
							const char *path,
							const char *root_path)
{
	GDBusClient *client;
	unsigned int i;

	if (!connection || !service)
		return NULL;

	client = g_try_new0(GDBusClient, 1);
	if (client == NULL)
		return NULL;

	if (dbus_connection_add_filter(connection, message_filter,
						client, NULL) == FALSE) {
		g_free(client);
		return NULL;
	}

	client->dbus_conn = dbus_connection_ref(connection);
	client->service_name = g_strdup(service);
	client->base_path = g_strdup(path);
	client->root_path = g_strdup(root_path);
	client->connected = FALSE;

	client->match_rules = g_ptr_array_sized_new(1);
	g_ptr_array_set_free_func(client->match_rules, g_free);

	client->watch = g_dbus_add_service_watch(connection, service,
						service_connect,
						service_disconnect,
						client, NULL);

	if (!root_path)
		return g_dbus_client_ref(client);

	client->added_watch = g_dbus_add_signal_watch(connection, service,
						client->root_path,
						DBUS_INTERFACE_OBJECT_MANAGER,
						"InterfacesAdded",
						interfaces_added,
						client, NULL);
	client->removed_watch = g_dbus_add_signal_watch(connection, service,
						client->root_path,
						DBUS_INTERFACE_OBJECT_MANAGER,
						"InterfacesRemoved",
						interfaces_removed,
						client, NULL);
	g_ptr_array_add(client->match_rules, g_strdup_printf("type='signal',"
				"sender='%s',path_namespace='%s'",
				client->service_name, client->base_path));

	for (i = 0; i < client->match_rules->len; i++) {
		modify_match(client->dbus_conn, "AddMatch",
				g_ptr_array_index(client->match_rules, i));
	}

	return g_dbus_client_ref(client);
}
Пример #27
0
/** \brief Read fresh TLE data into hash table.
 *  \param dir The directory to read from.
 *  \param fnam The name of the file to read from.
 *  \param fresh_data Hash table where the data should be stored.
 *  \return The number of satellites successfully read.
 * 
 * This function will read fresh TLE data from local files into memory.
 * If there is a saetllite category (.cat file) with the same name as the
 * input file it will also update the satellites in that category.
 */
static gint read_fresh_tle (const gchar *dir, const gchar *fnam, GHashTable *data)
{
    new_tle_t *ntle;
    tle_t      tle;
    gchar     *path;
    gchar      tle_str[3][80];
    gchar      tle_working[3][80];
    gchar      linetmp[80];
    guint      linesneeded = 3;
    gchar      catstr[6];
    gchar      idstr[7]="\0\0\0\0\0\0\0",idyearstr[3];
    gchar     *b;
    FILE      *fp;
    gint       retcode = 0;
    guint      catnr,i,idyear;
    guint     *key = NULL;

    /* category sync related */
    gchar     *catname, *catpath, *buff, **buffv;
    FILE      *catfile;
    gchar      category[80];
    gboolean   catsync = FALSE; /* whether .cat file should be synced */

    /* 
       Normal cases to check
       1. 3 line tle file as in amatuer.txt from celestrak
       2. 2 line tle file as in .... from celestrak

       corner cases to check 
       1. 3 line tle with something at the end. (nasa.all from amsat)
       2. 2 line tle with only one in the file
       3. 2 line tle file reading the last one.
    */




    path = g_strconcat (dir, G_DIR_SEPARATOR_S, fnam, NULL);

    fp = g_fopen (path, "r");

    if (fp != NULL) {

        /* Prepare .cat file for sync while we read data */
        buffv = g_strsplit (fnam, ".", 0);
        catname = g_strconcat (buffv[0], ".cat", NULL);
        g_strfreev (buffv);
        catpath = sat_file_name (catname);
        g_free (catname);

        /* read category name for catfile */
        catfile = g_fopen (catpath, "r");
        if (catfile!=NULL) {
            b = fgets (category, 80, catfile);
            if (b == NULL) {
                sat_log_log (SAT_LOG_LEVEL_ERROR,
                             _("%s:%s: There is no category in %s"),
                             __FILE__, __FUNCTION__, catpath);                
            }
            fclose (catfile);
            catsync = TRUE;
        }
        else {
            /* There is no category with this name (could be update from custom file) */
            sat_log_log (SAT_LOG_LEVEL_INFO,
                         _("%s:%s: There is no category called %s"),
                         __FILE__, __FUNCTION__, fnam);
        }

        /* reopen a new catfile and write category name */
        if (catsync) {
            catfile = g_fopen (catpath, "w");
            if (catfile != NULL) {
                fputs (category, catfile);
            }
            else {
                catsync = FALSE;
                sat_log_log (SAT_LOG_LEVEL_ERROR,
                             _("%s:%s: Could not reopen .cat file while reading TLE from %s"),
                             __FILE__, __FUNCTION__, fnam);
            }
            
            /* .cat file now contains the category name;
               satellite catnums will be added during update in the while loop */
        }
        
        /* set b to non-null as a flag */
        b = path;

        /* read lines from tle file */
        while (fgets (linetmp, 80, fp)) {
            /*read in the number of lines needed to potentially get to a new tle*/
            switch (linesneeded) {
            case 3:
                strncpy(tle_working[0],linetmp,80);
                /* b is being used a flag here
                   if b==NULL then we only have one line read in 
                   and there is no way we have a full tle as there 
                   is only one line in the buffer.
                   A TLE must be two or three lines.
                */
                b = fgets (tle_working[1], 80, fp);
                if (b==NULL) {
                    /* make sure there is no junk in tle_working[1] */
                    tle_working[1][0]='\0';
                    break;
                }
                /* make sure there is no junk in tle_working[2] */
                if (fgets (tle_working[2], 80, fp)==NULL) {
                    tle_working[2][0]='\0';
                }
                
                break;
            case 2:
                strncpy(tle_working[0],tle_working[2],80);
                strncpy(tle_working[1],linetmp,80);
                /* make sure there is no junk in tle_working[2] */
                if (fgets (tle_working[2], 80, fp)==NULL) {
                    tle_working[2][0]='\0';
                }
                break;
            case 1:
                strncpy(tle_working[0],tle_working[1],80);
                strncpy(tle_working[1],tle_working[2],80);
                strncpy(tle_working[2],linetmp,80);
                break;
            default:
                sat_log_log (SAT_LOG_LEVEL_ERROR,
                             _("%s:%s: Something wrote linesneeded to an illegal value %d"),
                             __FILE__, __FUNCTION__, linesneeded);
                break;
            }
            /* b can only be null if there is only one line in the buffer*/
            /* a tle must be two or three */
            if (b == NULL) {
                break;
            }
            /* remove leading and trailing whitespace to be more forgiving */
            g_strstrip(tle_working[0]);
            g_strstrip(tle_working[1]);
            g_strstrip(tle_working[2]);
            
            /* there are three possibilities at this point */
            /* first is that line 0 is a name and normal text for three line element and that lines 1 and 2 
               are the corresponding tle */
            /* second is that line 0 and line 1 are a tle for a bare tle */
            /* third is that neither of these is true and we are consuming either text at the top of the 
               file or a text file that happens to be in the update directory 
            */ 
            if ((tle_working[1][0] == '1') && 
                (tle_working[2][0] == '2') && 
                Checksum_Good(tle_working[1]) &&
                Checksum_Good(tle_working[2])) {
                sat_log_log (SAT_LOG_LEVEL_DEBUG,
                             _("%s:%s: Processing a three line TLE"),
                             __FILE__, __FUNCTION__);
                                
                /* it appears that the first line may be a name followed by a tle */
                strncpy(tle_str[0],tle_working[0],80);
                strncpy(tle_str[1],tle_working[1],80);
                strncpy(tle_str[2],tle_working[2],80);
                /* we consumed three lines so we need three lines */
                linesneeded = 3;
                
            } else if ((tle_working[0][0] == '1') && 
                       (tle_working[1][0] == '2') &&
                       Checksum_Good(tle_working[0]) && 
                       Checksum_Good(tle_working[1])) {
                sat_log_log (SAT_LOG_LEVEL_DEBUG,
                             _("%s:%s: Processing a bare two line TLE"),
                             __FILE__, __FUNCTION__);
                
                /* first line appears to belong to the start of bare TLE */
                /* put in a dummy name of form yyyy-nnaa base on international id */
                /* this special form will be overwritten if a three line tle ever has another name */
                
                strncpy(idstr,&tle_working[0][11],6);
                g_strstrip(idstr);
                strncpy(idyearstr,&tle_working[0][9],2);
                idstr[6]= '\0';
                idyearstr[2]= '\0';
                idyear = g_ascii_strtod(idyearstr,NULL);
                
                /* there is a two digit year field that started around sputnik */
                if (idyear >= 57)
                    idyear += 1900;
                else
                    idyear += 2000;

                snprintf(tle_str[0],79,"%d-%s",idyear,idstr);
                strncpy(tle_str[1],tle_working[0],80);
                strncpy(tle_str[2],tle_working[1],80);        
        
                /* we consumed two lines so we need two lines */
                linesneeded = 2;
            } else {
                /* we appear to have junk 
                   read another line in and do nothing else */
                linesneeded = 1;
                /* skip back to beginning of loop */
                continue;
            }


            tle_str[1][69] = '\0';
            tle_str[2][69] = '\0';

            /* copy catnum and convert to integer */
            for (i = 2; i < 7; i++) {
                catstr[i-2] = tle_str[1][i];
            }
            catstr[5] = '\0';
            catnr = (guint) g_ascii_strtod (catstr, NULL);


            if (Get_Next_Tle_Set (tle_str, &tle) != 1) {
                /* TLE data not good */
                sat_log_log (SAT_LOG_LEVEL_ERROR,
                             _("%s:%s: Invalid data for %d"),
                             __FILE__, __FUNCTION__, catnr);
            }
            else {

                if (catsync) {
                    /* store catalog number in catfile */
                    buff = g_strdup_printf ("%d\n", catnr);
                    fputs (buff, catfile);
                    g_free (buff);
                }

                /* add data to hash table */
                key = g_try_new0 (guint, 1);
                *key = catnr;
                
                ntle = g_hash_table_lookup (data, key);
                
                /* check if satellite already in hash table */
                if ( ntle == NULL) {

                    /* create new_tle structure */
                    ntle = g_try_new (new_tle_t, 1);
                    ntle->catnum = catnr;
                    ntle->epoch = tle.epoch;
                    ntle->status = tle.status;
                    ntle->satname = g_strdup (tle.sat_name);
                    ntle->line1   = g_strdup (tle_str[1]);
                    ntle->line2   = g_strdup (tle_str[2]);
                    ntle->srcfile = g_strdup (fnam);
                    ntle->isnew   = TRUE; /* flag will be reset when using data */

                    g_hash_table_insert (data, key, ntle);
                    retcode++;
                }
                else {
                    /* satellite is already in hash */
                    /* apply various merge routines */
                    
                    /* time merge */
                    if (ntle->epoch == tle.epoch) {
                        /* if satellite epoch has the same time,  merge status as appropriate */
                        if (ntle->status != tle.status) {
                            /* log if there is something funny about the data coming in */
                            sat_log_log (SAT_LOG_LEVEL_WARN,
                                         _("%s:%s: Two different statuses for %d (%s) at the same time."),
                                         __FILE__, __FUNCTION__, ntle->catnum, ntle->satname);
                            if ( tle.status != OP_STAT_UNKNOWN )
                                ntle->status = tle.status;
                        }
                    } 
                    else if ( ntle->epoch < tle.epoch ) {
                        /* if the satellite in the hash is older than 
                           the one just loaded, copy the values over. */

                        ntle->catnum = catnr;
                        ntle->epoch = tle.epoch;
                        ntle->status = tle.status;
                        g_free (ntle->line1);
                        ntle->line1   = g_strdup (tle_str[1]);
                        g_free (ntle->line2);
                        ntle->line2   = g_strdup (tle_str[2]);
                        g_free (ntle->srcfile);
                        ntle->srcfile = g_strdup (fnam);
                        ntle->isnew   = TRUE; /* flag will be reset when using data */
                    }
                    
                    /* merge based on name */
                    if (is_computer_generated_name (ntle->satname) && 
                        !is_computer_generated_name(tle_str[0])) {
                        g_free (ntle->satname);
                        ntle->satname = g_strdup (tle.sat_name);
                    }
                    
                    /* free the key since we do not commit it to the cache */
                    g_free (key);
                    

                }
            }

        }

        if (catsync) {
            /* close category file */
            fclose (catfile);
        }

        g_free (catpath);

        /* close input TLE file */
        fclose (fp);

    }

    else {
        sat_log_log (SAT_LOG_LEVEL_ERROR,
                     _("%s:%s: Failed to open %s"),
                     __FILE__, __FUNCTION__, path);
    }

    g_free (path);


    return retcode;
}
Пример #28
0
GDHCPServer *g_dhcp_server_new(GDHCPType type,
		int ifindex, GDHCPServerError *error)
{
	GDHCPServer *dhcp_server = NULL;

	if (ifindex < 0) {
		*error = G_DHCP_SERVER_ERROR_INVALID_INDEX;
		return NULL;
	}

	dhcp_server = g_try_new0(GDHCPServer, 1);
	if (!dhcp_server) {
		*error = G_DHCP_SERVER_ERROR_NOMEM;
		return NULL;
	}

	dhcp_server->interface = get_interface_name(ifindex);
	if (!dhcp_server->interface) {
		*error = G_DHCP_SERVER_ERROR_INTERFACE_UNAVAILABLE;
		goto error;
	}

	if (!interface_is_up(ifindex)) {
		*error = G_DHCP_SERVER_ERROR_INTERFACE_DOWN;
		goto error;
	}

	dhcp_server->server_nip = get_interface_address(ifindex);
	if (dhcp_server->server_nip == 0) {
		*error = G_DHCP_SERVER_ERROR_IP_ADDRESS_INVALID;
		goto error;
	}

	dhcp_server->nip_lease_hash = g_hash_table_new_full(g_direct_hash,
						g_direct_equal, NULL, NULL);
	dhcp_server->option_hash = g_hash_table_new_full(g_direct_hash,
						g_direct_equal, NULL, NULL);

	dhcp_server->started = FALSE;

	/* All the leases have the same fixed lease time,
	 * do not support DHCP_LEASE_TIME option from client.
	 */
	dhcp_server->lease_seconds = DEFAULT_DHCP_LEASE_SEC;

	dhcp_server->type = type;
	dhcp_server->ref_count = 1;
	dhcp_server->ifindex = ifindex;
	dhcp_server->listener_sockfd = -1;
	dhcp_server->listener_watch = -1;
	dhcp_server->listener_channel = NULL;
	dhcp_server->save_lease_func = NULL;
	dhcp_server->save_ack_lease_func = NULL;
	dhcp_server->debug_func = NULL;
	dhcp_server->debug_data = NULL;

	*error = G_DHCP_SERVER_ERROR_NONE;

	return dhcp_server;

error:
	g_free(dhcp_server->interface);
	g_free(dhcp_server);
	return NULL;
}
Пример #29
0
void *validate_value(gint value_id, gint input_type, void *value)
{
	// Local variables
	guint				base_type;
	guint				capabilities;
	gboolean			capability_check;
	gchar				*conversion_buffer = NULL;			// Used when converting between unicode character types
	gchar				*decimal_point;
	GString				*error_string;
	gchar				input_char;
	gunichar			input_char_unicode;
	gchar				*input_ptr;
	struct lconv		*locale_info;
	gboolean			match_found;
	gint				output_gint;
	gint				*output_gint_ptr;
	gfloat				output_gfloat;
	gfloat				*output_gfloat_ptr;
	GString				*output_gstring;
	guint				output_guint;
	guint				*output_guint_ptr;
	guint				string_counter;
	gint				string_length;
	gint				string_max;
	guint				string_min;
	gfloat				value_max;
	gfloat				value_min;


	// Initialise various things
	base_type = get_valid_fields_base_type(value_id);
	capabilities = get_valid_fields_capabilities(value_id);
	input_ptr = (gchar *) value;
	output_gstring = g_string_new(NULL);
	locale_info = localeconv();
	decimal_point = locale_info->decimal_point;

	switch (base_type)
	{
		case V_CHAR:

			// * We're validating a char or string *

			// We can only validate string input for this type of value
			if (V_CHAR != input_type)
			{
				return NULL;
			}

			// Get the length of the input string
			string_max = get_valid_fields_max_value(value_id);
			string_min = get_valid_fields_min_value(value_id);
			string_length = g_utf8_strlen(input_ptr, -1);

			// If the length of the string isn't in the acceptable range, return NULL
			if (string_length < string_min)
				return NULL;
			if ((string_length > string_max) && (-1 != string_max))  // -1 for string_max means "no maximum limit"
				return NULL;
			if (0 == string_length)
			{
				// 0 length string, so we just return it
				return output_gstring;
			}

			// Sanitise each character of the input string
			for (string_counter = 0; string_counter < string_length; string_counter++)
			{
				// Get the next character
				input_char_unicode = g_utf8_get_char_validated(input_ptr, -1);
				if ((gunichar)-1 == input_char_unicode)
				{
					// The returned character was not a valid unicode character, so we indicate failure
					return NULL;
				}
				if ((gunichar)-2 == input_char_unicode)
				{
					// The returned character was not a valid unicode character, so we indicate failure
					return NULL;
				}

				// Convert the character to UTF-8 so we can process it
				conversion_buffer = g_ucs4_to_utf8(&input_char_unicode, 1, NULL, NULL, NULL);

				// Determine which character we're examining
				if (TRUE == g_unichar_isalnum(input_char_unicode))
				{
					// It's a standard unicode alphanumeric character, so we accept it as is
					g_string_append_printf(output_gstring, "%s", conversion_buffer);
					input_ptr = g_utf8_find_next_char(input_ptr, NULL);
				}
				else
				{
					// * The input wasn't a standard alphanumic character, so check if it *
					// * is one of the characters in the capabilities list for this field *
					match_found = FALSE;
					capability_check = V_ANY_UNICHAR & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have any valid unicode character
						if (TRUE == g_unichar_validate(input_char_unicode))
						{
							// Yes, this is a valid unicode character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_SPACES & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have spaces
						if (0 == g_strcmp0(" ", conversion_buffer))
						{
							// Yes, this is a space character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_FULL_STOP & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have full stops
						if (0 == g_strcmp0(".", conversion_buffer))
						{
							// Yes, this is a full stop character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_HYPENS & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have hypens
						if (0 == g_strcmp0("-", conversion_buffer))
						{
							// Yes, this is a hypen character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_UNDERSCORES & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have underscores
						if (0 == g_strcmp0("_", conversion_buffer))
						{
							// Yes, this is an underscore character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_PATH_SEP & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have path separator characters ('/', '\')
						if ((0 == g_strcmp0("/", conversion_buffer)) || (0 == g_strcmp0("\\", conversion_buffer)))
						{
							// Yes, this is a path separator character
							match_found = TRUE;
							output_gstring = g_string_append_c(output_gstring, G_DIR_SEPARATOR);  // Output the OS correct version
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_EQUALS & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have equals signs
						if (0 == g_strcmp0("=", conversion_buffer))
						{
							// Yes, this is an equals sign character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_FORWARD_SLASHES & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have forward slashes
						if (0 == g_strcmp0("/", conversion_buffer))
						{
							// Yes, this is a forward slash character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_NEW_LINES & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have new line characters
						if (0 == g_strcmp0("\n", conversion_buffer))
						{
							// Yes, this is a new line character
							match_found = TRUE;
							output_gstring = g_string_append_c(output_gstring, '\n');
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_PLUSES & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have pluses
						if (0 == g_strcmp0("+", conversion_buffer))
						{
							// Yes, this is a plus character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_PERCENT & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have the percent sign
						if (0 == g_strcmp0("%", conversion_buffer))
						{
							// Yes, this is a percent sign
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_COLON & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have colons
						if (0 == g_strcmp0(":", conversion_buffer))
						{
							// Yes, this is a colon character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_AT & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have the at symbol
						if (0 == g_strcmp0("@", conversion_buffer))
						{
							// Yes, this is an at character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_QUESTION & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have the question mark
						if (0 == g_strcmp0("?", conversion_buffer))
						{
							// Yes, this is a question mark character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}
					capability_check = V_AMPERSAND & capabilities;
					if (FALSE != capability_check)
					{
						// This field is allowed to have the ampersand character
						if (0 == g_strcmp0("&", conversion_buffer))
						{
							// Yes, this is an ampersand character
							match_found = TRUE;
							g_string_append_printf(output_gstring, "%s", conversion_buffer);
							input_ptr = g_utf8_find_next_char(input_ptr, NULL);
							continue;
						}
					}

					// The character we are checking is not in the list of valid inputs for this field
					if (FALSE == match_found)
					{
						g_free(conversion_buffer);
						g_string_free(output_gstring, TRUE);
						return NULL;
					}
				}
			}

			// Remove any leading and/or trailing white space
			output_gstring->str = g_strstrip(output_gstring->str);
			output_gstring->len = strlen(output_gstring->str);

			// Recheck the length of the output string
			if (output_gstring->len < string_min)
			{
				g_free(conversion_buffer);
				g_string_free(output_gstring, TRUE);
				return NULL;
			}

			// Free the memory used so far
			if (0 != string_length)
			{
				g_free(conversion_buffer);
			}

			// The string seems to be valid, so return it for use
			return output_gstring;

			break;

		case V_FLOAT_UNSIGNED:

			// * We're validating an unsigned float *

			// If we're working with string input, we need to convert it to a float first
			if (V_CHAR == input_type)
			{
				// * We're working with string input *

				// Get the length of the input string
				string_length = strlen((gchar *) value);
	
				// Sanitise each character of the input string
				for (string_counter = 0; string_counter < string_length; string_counter++)
				{
					input_char = ((gchar *) value)[string_counter];

					// Check for decimal digits
					if (TRUE == g_ascii_isdigit(input_char))
					{
						output_gstring = g_string_append_c(output_gstring, input_char);
					}
					else
					{
						// This field is allowed to have full stops.  Is this character a full stop?
						if (0 == g_ascii_strncasecmp(".", &input_char, 1))
						{
							// Yes, this is a full stop character
							output_gstring = g_string_append_c(output_gstring, *decimal_point);
							match_found = TRUE;
							continue;
						}

						// This field is allowed to have commas (equiv to full stop in some locales).  Is this character a comma?
						if (0 == g_ascii_strncasecmp(",", &input_char, 1))
						{
							// Yes, this is a comma character
							output_gstring = g_string_append_c(output_gstring, *decimal_point);
							match_found = TRUE;
							continue;
						}

						// The character we are checking is not in the list of valid inputs for this field
						if (FALSE == match_found)
						{
							g_string_free(output_gstring, TRUE);
							return NULL;
						}
					}
				}

				// Convert the string to a float
				output_gfloat = (gfloat) g_strtod(output_gstring->str, NULL);
			}
			else
			{
				// We're working with a float input, so just copy the value directly
				output_gfloat = *((gfloat *) value);
			}

			// Is the float value within the defined bounds?
			value_max = get_valid_fields_max_value(value_id);
			value_min = get_valid_fields_min_value(value_id);
			if ((output_gfloat < value_min) || (output_gfloat > value_max))
			{
				// Value is out of bounds, so fail
				g_string_free(output_gstring, TRUE);
				return NULL;
			}

			// The value looks ok, so we copy it to newly allocated memory, to pass it back
			output_gfloat_ptr = g_try_new0(gfloat, 1);
			if (NULL == output_gfloat_ptr)
			{
				// Unable to allocate memory for the new value, so fail
				g_string_free(output_gstring, TRUE);
				return NULL;
			}
			*output_gfloat_ptr = output_gfloat;

			// Free the string memory allocated in this function
			g_string_free(output_gstring, TRUE);

			return output_gfloat_ptr;

		case V_INT_UNSIGNED:

			// * We're validating an unsigned integer *

			// If we're working with string input, we need to convert it to an integer first
			if (V_CHAR == input_type)
			{
				// * We're working with string input *

				// Get the length of the input string
				string_length = strlen((gchar *) value);
	
				// Sanitise each character of the input string
				for (string_counter = 0; string_counter < string_length; string_counter++)
				{
					input_char = ((gchar *) value)[string_counter];

					// Check for decimal digits
					if (TRUE == g_ascii_isdigit(input_char))
					{
						output_gstring = g_string_append_c(output_gstring, input_char);
					}
					else
					{
						// This wasn't a valid character
						g_string_free(output_gstring, TRUE);
						return NULL;
					}
				}

				// Convert the string to an integer
				output_guint = atoi(output_gstring->str);
			}
			else
			{
				// We're working with integer input, so just copy the value directly
				output_guint = *((guint *) value);
			}

			// Is the integer value within the defined bounds?
			value_max = get_valid_fields_max_value(value_id);
			value_min = get_valid_fields_min_value(value_id);
			if ((output_guint < value_min) || (output_guint > value_max))
			{
				// Value is out of bounds, so fail
				g_string_free(output_gstring, TRUE);
				return NULL;
			}

			// The value looks ok, so we copy it to newly allocated memory, to pass it back
			output_guint_ptr = g_try_new0(guint, 1);
			if (NULL == output_guint_ptr)
			{
				// Unable to allocate memory for the new value, so fail
				g_string_free(output_gstring, TRUE);
				return NULL;
			}
			*output_guint_ptr = output_guint;

			// Free the string memory allocated in this function
			g_string_free(output_gstring, TRUE);

			return output_guint_ptr;

		case V_INT_SIGNED:

			// * We're validating a signed integer *

			// If we're working with string input, we need to convert it to an integer first
			if (V_CHAR == input_type)
			{
				// * We're working with string input *

				// Get the length of the input string
				string_length = strlen((gchar *) value);

				// Sanitise each character of the input string
				for (string_counter = 0; string_counter < string_length; string_counter++)
				{
					input_char = ((gchar *) value)[string_counter];

					// Check for decimal digits
					if (TRUE == g_ascii_isdigit(input_char))
					{
						output_gstring = g_string_append_c(output_gstring, input_char);
					}
					else
					{
						// * The input wasn't a standard digit character, so check if it *
						// * is one of the characters in the capabilities list for this field *
						match_found = FALSE;
						capability_check = V_HYPENS & capabilities;
						if (FALSE != capability_check)
						{
							// This field is allowed to have hypens
							if (0 == g_ascii_strncasecmp("-", &input_char, 1))
							{
								// Yes, this is a hypen character
								match_found = TRUE;
								g_string_append_printf(output_gstring, "%s", "-");
							}
						}

						// The character we are checking is not in the list of valid inputs for this field
						if (FALSE == match_found)
						{
							g_string_free(output_gstring, TRUE);
							return NULL;
						}
					}
				}

				// Convert the string to an integer
				output_gint = atoi(output_gstring->str);
			}
			else
			{
				// We're working with integer input, so just copy the value directly
				output_gint = *((gint *) value);
			}

			// Is the integer value within the defined bounds?
			value_max = get_valid_fields_max_value(value_id);
			value_min = get_valid_fields_min_value(value_id);
			if ((output_gint < value_min) || (output_gint > value_max))
			{
				// Value is out of bounds, so fail
				g_string_free(output_gstring, TRUE);
				return NULL;
			}

			// The value looks ok, so we copy it to newly allocated memory, to pass it back
			output_gint_ptr = g_try_new0(gint, 1);
			if (NULL == output_gint_ptr)
			{
				// Unable to allocate memory for the new value, so fail
				g_string_free(output_gstring, TRUE);
				return NULL;
			}
			*output_gint_ptr = output_gint;

			// Free the string memory allocated in this function
			g_string_free(output_gstring, TRUE);

			return output_gint_ptr;

		case V_RESOLUTION:

				// * We're working with a resolution (text string) input.  i.e. '1920x1200 pixels' *

				// Get the length of the input string
				string_length = strlen((gchar *) value);
				string_max = get_valid_fields_max_value(value_id);
				string_min = get_valid_fields_min_value(value_id);

				// If the length of the string isn't in the acceptable range, return NULL
				if ((string_length < string_min) || (string_length > string_max))
					return NULL;

				// Sanitise each character of the input string
				for (string_counter = 0; string_counter < string_length; string_counter++)
				{
					input_char = ((gchar *) value)[string_counter];

					// Check for decimal digits
					if (TRUE == g_ascii_isdigit(input_char))
					{
						output_gstring = g_string_append_c(output_gstring, input_char);
					}
					else
					{
						match_found = FALSE;

						// This field is allowed to have the ' ' and 'x' characters .  Is this character one of those?
						if (0 == g_ascii_strncasecmp(" ", &input_char, 1))
						{
							// Yes, this is a space character, so we've already collected the required resolution
							// info and we can just return the resolution part of the string so far

							// Remove any leading and/or trailing white space
							output_gstring->str = g_strstrip(output_gstring->str);
							output_gstring->len = strlen(output_gstring->str);

							// Recheck the length of the output string
							if ((string_length < string_min) || (string_length > string_max))
								return NULL;

							// The string seems to be valid, so return it for use
							return output_gstring;
						}
						if (0 == g_ascii_strncasecmp("x", &input_char, 1))
						{
							// Yes, this is a 'x' character
							output_gstring = g_string_append_c(output_gstring, 'x');
							match_found = TRUE;
							continue;
						}
						if (FALSE == match_found)
						{
							// This wasn't a valid character
							g_string_free(output_gstring, TRUE);
							return NULL;
						}
					}
				}

				// Remove any leading and/or trailing white space
				output_gstring->str = g_strstrip(output_gstring->str);
				output_gstring->len = strlen(output_gstring->str);

				// Recheck the length of the output string
				if ((string_length < string_min) || (string_length > string_max))
					return NULL;

				// The string seems to be valid, so return it for use
				return output_gstring;

		case V_ZOOM:

			// * We're working with a zoom level.  i.e. "100%" or "Fit to width" *

			// Get the length of the input string
			string_length = g_utf8_strlen((gchar *) value, -1);
			string_max = get_valid_fields_max_value(value_id);
			string_min = get_valid_fields_min_value(value_id);

			// If the length of the string isn't in the acceptable range, return NULL
			if ((string_length < string_min) || (string_length > string_max))
				return NULL;

			// If the string is "Fit to width" or a localised version of it
			if ((0 == g_strcmp0("Fit to width", (gchar *) value)) || (0 == g_strcmp0(_("Fit to width"), (gchar *) value)))
			{
				// Yes, this is the "Fit to width" value
				output_gstring = g_string_assign(output_gstring, value);
				return output_gstring;
			}

			// * The incoming string isn't the "Fit to width" value, *
			// * so should only consist of decimal characters and '%' *

			// Sanitise each character of the input string
			for (string_counter = 0; string_counter < string_length; string_counter++)
			{
				input_char = ((gchar *) value)[string_counter];

				// Check for decimal digits
				if (TRUE == g_ascii_isdigit(input_char))
				{
					output_gstring = g_string_append_c(output_gstring, input_char);
					continue;
				}
				// Check for '%' character
				if (0 == g_ascii_strncasecmp("%", &input_char, 1))
				{
					// Yes, this is a '%' character
					output_gstring = g_string_append_c(output_gstring, '%');
					continue;
				}
				// This wasn't a valid character
				g_string_free(output_gstring, TRUE);
				return NULL;
			}

			return output_gstring;

		default:

			// Unknown value type, we should never get here
			error_string = g_string_new(NULL);
			g_string_printf(error_string, "%s ED119: %s - '%s'", _("Error"), _("Unknown value passed to validation function"), get_valid_fields_name(value_id));
			display_warning(error_string->str);
			g_string_free(error_string, TRUE);

			return NULL;
	}

	// If we get here, then something went wrong!
	return NULL;
}
Пример #30
0
/** \brief Update TLE data in a file.
 *  \param ldname Directory name for gpredict tle files.
 *  \param fname The name of the TLE file.
 *  \param data The hash table containing the fresh data.
 *  \param sat_upd OUT: number of sats updated.
 *  \param sat_ski OUT: number of sats skipped.
 *  \param sat_nod OUT: number of sats for which no data found
 *  \param sat_tot OUT: total number of sats
 *
 * For each satellite in the TLE file ldname/fnam, this function
 * checks whether there is any newer data available in the hash table.
 * If yes, the function writes the fresh data to temp_file, if no, the
 * old data is copied to temp_file.
 * When all sats have been copied ldname/fnam is deleted and temp_file
 * is renamed to ldname/fnam.
 */
static void update_tle_in_file (const gchar *ldname,
                                const gchar *fname,
                                GHashTable  *data,
                                guint       *sat_upd,
                                guint       *sat_ski,
                                guint       *sat_nod,
                                guint       *sat_tot)
{
    gchar     *path;
    guint      updated = 0;  /* number of updated sats */
    guint      nodata  = 0;  /* no sats for which no fresh data available */
    guint      skipped = 0;  /* no. sats where fresh data is older */
    guint      total   = 0;  /* total no. of sats in gpredict tle file */
    gchar    **catstr;
    guint      catnr;
    guint     *key = NULL;
    tle_t      tle;
    new_tle_t *ntle;
    op_stat_t  status;
    GError    *error = NULL;
    GKeyFile  *satdata;
    gchar     *tlestr1, *tlestr2, *rawtle, *satname, *satnickname;
    gboolean   updateddata;
    
    /* get catalog number for this satellite */
    catstr = g_strsplit (fname, ".sat", 0);
    catnr = (guint) g_ascii_strtod (catstr[0], NULL);
    

    /* see if we have new data for this satellite */
    key = g_try_new0 (guint, 1);
    *key = catnr;
    ntle = (new_tle_t *) g_hash_table_lookup (data, key);
    g_free (key);

    if (ntle == NULL) {
        /* no new data found for this sat => obsolete */
        nodata++;
        
        /* check if obsolete sats should be deleted */
        /**** FIXME: This is dangereous, so we omit it */
        sat_log_log (SAT_LOG_LEVEL_INFO,
                     _("%s: No new TLE data found for %d. Satellite might be obsolete."),
                     __FUNCTION__, catnr);
    }
    else { 
        /* open input file (file containing old tle) */
        path = g_strconcat (ldname, G_DIR_SEPARATOR_S, fname, NULL);
        satdata = g_key_file_new ();
        if (!g_key_file_load_from_file (satdata, path, G_KEY_FILE_KEEP_COMMENTS, &error)) {
            sat_log_log (SAT_LOG_LEVEL_ERROR,
                         _("%s: Error loading %s (%s)"),
                         __FUNCTION__, path, error->message);
            g_clear_error (&error);
            
            skipped++;
            
        } else {
            
            /* This satellite is not new */
            ntle->isnew = FALSE;

            /* get TLE data */
            tlestr1 = g_key_file_get_string (satdata, "Satellite", "TLE1", NULL);
            if (error != NULL) {
                sat_log_log (SAT_LOG_LEVEL_ERROR,
                             _("%s: Error reading TLE line 2 from %s (%s)"),
                             __FUNCTION__, path, error->message);
                g_clear_error (&error);
            }
            tlestr2 = g_key_file_get_string (satdata, "Satellite", "TLE2", NULL);
            if (error != NULL) {
                sat_log_log (SAT_LOG_LEVEL_ERROR,
                             _("%s: Error reading TLE line 2 from %s (%s)"),
                             __FUNCTION__, path, error->message);
                g_clear_error (&error);
            }
            
            /* get name data */
            satname = g_key_file_get_string (satdata, "Satellite", "NAME", NULL);
            satnickname = g_key_file_get_string (satdata, "Satellite", "NICKNAME", NULL);

            /* get status data */
            if (g_key_file_has_key(satdata,"Satellite","STATUS", NULL)) {
                status = g_key_file_get_integer (satdata, "Satellite", "STATUS", NULL);
            }
            else {
                status = OP_STAT_UNKNOWN;
            }
            
            rawtle = g_strconcat (tlestr1, tlestr2, NULL);

            if (!Good_Elements (rawtle)) {
                sat_log_log (SAT_LOG_LEVEL_WARN,
                             _("%s: Current TLE data for %d appears to be bad"),
                             __FUNCTION__, catnr);
                /* set epoch to zero so it gets overwritten */
                tle.epoch = 0;
            } else {
                Convert_Satellite_Data (rawtle, &tle);
            }
            g_free (tlestr1);
            g_free (tlestr2);
            g_free (rawtle);
            
            /* Initialize flag for update */
            updateddata = FALSE;

            if (ntle->satname != NULL) {
                /* when a satellite first appears in the elements it is sometimes refered to by the 
                   international designator which is awkward after it is given a name */
                if (!is_computer_generated_name(ntle->satname)) {
                    
                    if (is_computer_generated_name (satname)) {
                        sat_log_log (SAT_LOG_LEVEL_INFO,
                                     _("%s: Data for  %d updated for name."),
                                     __FUNCTION__, catnr);
                        g_key_file_set_string (satdata, "Satellite", "NAME", ntle->satname);
                        updateddata = TRUE;
                    }
                    
                    /* FIXME what to do about nickname Possibilities: */
                    /* clobber with name */
                    /* clobber if nickname and name were same before */ 
                    /* clobber if international designator */
                    if ( is_computer_generated_name (satnickname) ) {
                        sat_log_log (SAT_LOG_LEVEL_INFO,
                                     _("%s: Data for  %d updated for nickname."),
                                     __FUNCTION__, catnr);
                        g_key_file_set_string (satdata, "Satellite", "NICKNAME", ntle->satname);
                        updateddata = TRUE;
                    }
                }
            }

            g_free(satname);
            g_free(satnickname);

            if (tle.epoch < ntle->epoch) {
                /* new data is newer than what we already have */
                /* store new data */
                sat_log_log (SAT_LOG_LEVEL_INFO,
                             _("%s: Data for  %d updated for tle."),
                             __FUNCTION__, catnr);
                g_key_file_set_string (satdata, "Satellite", "TLE1", ntle->line1);
                g_key_file_set_string (satdata, "Satellite", "TLE2", ntle->line2);
                g_key_file_set_integer (satdata, "Satellite", "STATUS", ntle->status);
                updateddata = TRUE;

            } else if (tle.epoch == ntle->epoch) {
                if  ((status != ntle->status) && (ntle->status != OP_STAT_UNKNOWN)){
                    sat_log_log (SAT_LOG_LEVEL_INFO,
                                 _("%s: Data for  %d updated for operational status."),
                                 __FUNCTION__, catnr);
                    g_key_file_set_integer (satdata, "Satellite", "STATUS", ntle->status);
                    updateddata = TRUE;
                }
            }
            
            if (updateddata ==TRUE) {
                if (gpredict_save_key_file(satdata, path)) {
                    skipped++;
                } else {
                    updated++;
                }
                
            }
            else {
                skipped++;
            }
        }
     
        g_key_file_free (satdata);
        g_free (path);
        
    }
    g_strfreev (catstr);

    /* update out parameters */
    *sat_upd = updated;
    *sat_ski = skipped;
    *sat_nod = nodata;
    *sat_tot = total;

}