/** * gwy_interpolation_interpolate_2d: * @x: X-position in interval [0,1) to get value at. * @y: Y-position in interval [0,1) to get value at. * @rowstride: Row stride of @coeff. * @coeff: Array of support-length-squared size with interpolation coefficients * (that are equal to data values for an interpolating basis). * @interpolation: Interpolation type to use. * * Interpolates a signle data point in two dimensions. * * Returns: Interpolated value. * * Since: 2.2 **/ gdouble gwy_interpolation_interpolate_2d(gdouble x, gdouble y, gint rowstride, const gdouble *coeff, GwyInterpolationType interpolation) { gdouble *wx, *wy; gint i, j, suplen; gdouble v, vx; g_return_val_if_fail(x >= 0.0 && x <= 1.0 && y >= 0.0 && y <= 1.0, 0.0); suplen = gwy_interpolation_get_support_size(interpolation); if (G_UNLIKELY(suplen == 0)) return 0.0; g_return_val_if_fail(suplen > 0, 0.0); wx = g_newa(gdouble, suplen); wy = g_newa(gdouble, suplen); gwy_interpolation_get_weights(x, interpolation, wx); gwy_interpolation_get_weights(y, interpolation, wy); v = 0.0; for (i = 0; i < suplen; i++) { vx = 0.0; for (j = 0; j < suplen; j++) vx += coeff[i*rowstride + j]*wx[j]; v += wy[i]*vx; } return v; }
/* send login packet to QQ server */ static void qq_send_packet_login(PurpleConnection *gc, guint8 token_length, guint8 *token) { qq_data *qd; guint8 *buf, *cursor, *raw_data, *encrypted_data; guint16 seq_ret; gint encrypted_len, bytes; gint pos; qd = (qq_data *) gc->proto_data; buf = g_newa(guint8, MAX_PACKET_SIZE); raw_data = g_newa(guint8, QQ_LOGIN_DATA_LENGTH); encrypted_data = g_newa(guint8, QQ_LOGIN_DATA_LENGTH + 16); /* 16 bytes more */ qd->inikey = _gen_login_key(); /* now generate the encrypted data * 000-015 use pwkey as key to encrypt empty string */ qq_crypt(ENCRYPT, (guint8 *) "", 0, qd->pwkey, raw_data, &encrypted_len); /* 016-016 */ raw_data[16] = 0x00; /* 017-020, used to be IP, now zero */ *((guint32 *) (raw_data + 17)) = 0x00000000; /* 021-022, used to be port, now zero */ *((guint16 *) (raw_data + 21)) = 0x0000; /* 023-051, fixed value, unknown */ g_memmove(raw_data + 23, login_23_51, 29); /* 052-052, login mode */ raw_data[52] = qd->login_mode; /* 053-068, fixed value, maybe related to per machine */ g_memmove(raw_data + 53, login_53_68, 16); /* 069, login token length */ raw_data[69] = token_length; pos = 70; /* 070-093, login token, normally 24 bytes */ g_memmove(raw_data + pos, token, token_length); pos += token_length; /* 100 bytes unknown */ g_memmove(raw_data + pos, login_100_bytes, 100); pos += 100; /* all zero left */ memset(raw_data+pos, 0, QQ_LOGIN_DATA_LENGTH - pos); qq_crypt(ENCRYPT, raw_data, QQ_LOGIN_DATA_LENGTH, qd->inikey, encrypted_data, &encrypted_len); cursor = buf; bytes = 0; bytes += _create_packet_head_seq(buf, &cursor, gc, QQ_CMD_LOGIN, TRUE, &seq_ret); bytes += create_packet_dw(buf, &cursor, qd->uid); bytes += create_packet_data(buf, &cursor, qd->inikey, QQ_KEY_LENGTH); bytes += create_packet_data(buf, &cursor, encrypted_data, encrypted_len); bytes += create_packet_b(buf, &cursor, QQ_PACKET_TAIL); if (bytes == (cursor - buf)) /* packet creation OK */ _qq_send_packet(gc, buf, bytes, QQ_CMD_LOGIN); else purple_debug(PURPLE_DEBUG_ERROR, "QQ", "Fail create login packet\n"); }
static gint send_room_cmd(PurpleConnection *gc, guint8 room_cmd, guint32 room_id, guint8 *data, gint data_len, UPDCLS update_class, guint32 ship32) { qq_data *qd; guint8 *buf; gint buf_len; guint8 *encrypted; gint encrypted_len; gint bytes_sent; guint16 seq; g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1); qd = (qq_data *) gc->proto_data; buf = g_newa(guint8, MAX_PACKET_SIZE); memset(buf, 0, MAX_PACKET_SIZE); /* encap room_cmd and room id to buf*/ buf_len = 0; buf_len += qq_put8(buf + buf_len, room_cmd); if (room_id != 0) { /* id 0 is for QQ Demo Group, now they are closed*/ buf_len += qq_put32(buf + buf_len, room_id); } if (data != NULL && data_len > 0) { buf_len += qq_putdata(buf + buf_len, data, data_len); } qd->send_seq++; seq = qd->send_seq; /* Encrypt to encrypted with session_key */ /* at most 17 bytes more */ encrypted = g_newa(guint8, buf_len + 17); encrypted_len = qq_encrypt(encrypted, buf, buf_len, qd->session_key); if (encrypted_len < 16) { purple_debug_error("QQ_ENCRYPT", "Error len %d: [%05d] %s (0x%02X)\n", encrypted_len, seq, qq_get_room_cmd_desc(room_cmd), room_cmd); return -1; } bytes_sent = packet_send_out(gc, QQ_CMD_ROOM, seq, encrypted, encrypted_len); #if 1 /* qq_show_packet("send_room_cmd", buf, buf_len); */ purple_debug_info("QQ", "<== [%05d] %s (0x%02X) to room %d, datalen %d\n", seq, qq_get_room_cmd_desc(room_cmd), room_cmd, room_id, buf_len); #endif qq_trans_add_room_cmd(gc, seq, room_cmd, room_id, encrypted, encrypted_len, update_class, ship32); return bytes_sent; }
gboolean peas_gi_method_call (GObject *instance, GICallableInfo *func_info, GType iface_type, const gchar *method_name, GIArgument *args, GIArgument *return_value) { gint n_args; guint n_in_args, n_out_args; GIArgument *in_args, *out_args; gboolean ret = TRUE; GError *error = NULL; g_return_val_if_fail (G_IS_OBJECT (instance), FALSE); g_return_val_if_fail (func_info != NULL, FALSE); g_return_val_if_fail (G_TYPE_IS_INTERFACE (iface_type), FALSE); g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (instance, iface_type), FALSE); g_return_val_if_fail (method_name != NULL, FALSE); n_args = g_callable_info_get_n_args (func_info); g_return_val_if_fail (n_args >= 0, FALSE); n_in_args = 0; n_out_args = 0; in_args = g_newa (GIArgument, n_args + 1); out_args = g_newa (GIArgument, n_args); peas_gi_split_in_and_out_arguments (func_info, args, in_args+1, &n_in_args, out_args, &n_out_args); /* Set the object as the first argument for the method. */ in_args[0].v_pointer = instance; n_in_args++; g_debug ("Calling '%s.%s' on '%p'", g_type_name (iface_type), method_name, instance); ret = g_function_info_invoke (func_info, in_args, n_in_args, out_args, n_out_args, return_value, &error); if (!ret) { g_warning ("Error while calling '%s.%s': %s", g_type_name (iface_type), method_name, error->message); g_error_free (error); } return ret; }
/** * gwy_interpolation_get_dval_of_equidists: * @x: Possibily noninteger position in @data to get value at. * @data: Array of 4 values to interpolate between (see below). * @interpolation: Interpolation type to use. * * Computes interpolated value from 2 or 4 equidistant values. * * For %GWY_INTERPOLATION_NONE no @data value is actually used, and zero is * returned. * * For %GWY_INTERPOLATION_ROUND or %GWY_INTERPOLATION_LINEAR * it is enough to set middle two @data values, that to use @data in format * {0, data[i], data[i+1], 0} and function computes value at data[i+x] * (the outer values are not used). * * For four value interpolations you have to prepare @data as * {data[i-1], data[i], data[i+1], data[i+2]} and function again * returns value at data[i+x]. * * Interpolation with non-interpolating bases are silently replaced with an * interpolating function with the same support size. See * gwy_interpolation_interpolate_1d() for a function interpolating from * interpolation coefficients. * * Returns: Interpolated value. **/ gdouble gwy_interpolation_get_dval_of_equidists(gdouble x, gdouble *data, GwyInterpolationType interpolation) { gint l; gdouble *w; gdouble rest; x += 1.0; l = floor(x); rest = x - (gdouble)l; g_return_val_if_fail(x >= 1 && x < 2, 0.0); if (rest == 0) return data[l]; switch (interpolation) { case GWY_INTERPOLATION_NONE: return 0.0; break; case GWY_INTERPOLATION_ROUND: case GWY_INTERPOLATION_LINEAR: w = g_newa(gdouble, 2); gwy_interpolation_get_weights(rest, interpolation, w); return w[0]*data[l] + w[1]*data[l + 1]; break; /* One cannot do B-spline and o-MOMS this way. Read e.g. * `Interpolation Revisited' by Philippe Thevenaz for explanation. * Replace them with Key. */ case GWY_INTERPOLATION_BSPLINE: case GWY_INTERPOLATION_OMOMS: interpolation = GWY_INTERPOLATION_KEY; case GWY_INTERPOLATION_KEY: case GWY_INTERPOLATION_NNA: case GWY_INTERPOLATION_SCHAUM: w = g_newa(gdouble, 4); gwy_interpolation_get_weights(rest, interpolation, w); return w[0]*data[l - 1] + w[1]*data[l] + w[2]*data[l + 1] + w[3]*data[l + 2]; break; default: g_return_val_if_reached(0.0); break; } }
/** * peas_extension_set_call_valist: (skip) * @set: A #PeasExtensionSet. * @method_name: the name of the method that should be called. * @va_args: the arguments for the method. * * Call a method on all the #PeasExtension instances contained in @set. * * See peas_extension_call_valist() for more information. * * Deprecated: 1.2. Use peas_extension_set_foreach() instead. * * Return value: %TRUE on successful call. */ gboolean peas_extension_set_call_valist (PeasExtensionSet *set, const gchar *method_name, va_list va_args) { GICallableInfo *callable_info; GIArgument *args; gint n_args; g_return_val_if_fail (PEAS_IS_EXTENSION_SET (set), FALSE); g_return_val_if_fail (method_name != NULL, FALSE); callable_info = peas_gi_get_method_info (set->priv->exten_type, method_name); /* Already warned */ if (callable_info == NULL) return FALSE; n_args = g_callable_info_get_n_args (callable_info); g_return_val_if_fail (n_args >= 0, FALSE); args = g_newa (GIArgument, n_args); peas_gi_valist_to_arguments (callable_info, va_args, args, NULL); g_base_info_unref ((GIBaseInfo *) callable_info); return peas_extension_set_callv (set, method_name, args); }
/** * gwy_inventory_restore_order: * @inventory: An inventory. * * Assures an inventory is sorted. **/ void gwy_inventory_restore_order(GwyInventory *inventory) { guint i; gint *new_order; g_return_if_fail(GWY_IS_INVENTORY(inventory)); g_return_if_fail(!inventory->is_const); g_return_if_fail(inventory->item_type.compare); if (inventory->is_sorted) return; /* Make sure old order is remembered in @idx */ if (inventory->needs_reindex) gwy_inventory_reindex(inventory); g_array_sort_with_data(inventory->ridx, (GCompareDataFunc)gwy_inventory_compare_indices, inventory); new_order = g_newa(gint, inventory->items->len); /* Fill new_order with indices: new_order[new_position] = old_position */ for (i = 0; i < inventory->ridx->len; i++) new_order[i] = g_array_index(inventory->idx, guint, g_array_index(inventory->ridx, guint, i)); inventory->needs_reindex = TRUE; inventory->is_sorted = TRUE; g_signal_emit(inventory, gwy_inventory_signals[ITEMS_REORDERED], 0, new_order); }
/* send IM to a group */ void qq_send_packet_group_im(GaimConnection *gc, qq_group *group, const gchar *msg) { gint data_len, bytes; guint8 *raw_data, *cursor, *send_im_tail; guint16 msg_len; gchar *msg_filtered; g_return_if_fail(group != NULL && msg != NULL); msg_filtered = gaim_markup_strip_html(msg); msg_len = strlen(msg_filtered); data_len = 7 + msg_len + QQ_SEND_IM_AFTER_MSG_LEN; raw_data = g_newa(guint8, data_len); cursor = raw_data; bytes = 0; bytes += create_packet_b(raw_data, &cursor, QQ_GROUP_CMD_SEND_MSG); bytes += create_packet_dw(raw_data, &cursor, group->internal_group_id); bytes += create_packet_w(raw_data, &cursor, msg_len + QQ_SEND_IM_AFTER_MSG_LEN); bytes += create_packet_data(raw_data, &cursor, (guint8 *) msg_filtered, msg_len); send_im_tail = qq_get_send_im_tail(NULL, NULL, NULL, FALSE, FALSE, FALSE, QQ_SEND_IM_AFTER_MSG_LEN); bytes += create_packet_data(raw_data, &cursor, send_im_tail, QQ_SEND_IM_AFTER_MSG_LEN); g_free(send_im_tail); g_free(msg_filtered); if (bytes == data_len) /* create OK */ qq_send_group_cmd(gc, group, raw_data, data_len); else gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Fail creating group_im packet, expect %d bytes, build %d bytes\n", data_len, bytes); }
static void gwy_layer_basic_connect_fixed(GwyLayerBasic *basic_layer) { GwyDataViewLayer *layer; const gchar *prefix; gchar *detailed_signal; guint len; layer = GWY_DATA_VIEW_LAYER(basic_layer); if (!layer->data || !basic_layer->fixed_key) return; prefix = g_quark_to_string(basic_layer->fixed_key); len = strlen(prefix); detailed_signal = g_newa(gchar, len + sizeof("item-changed::") + sizeof("/min")); len += sizeof("item-changed::"); g_stpcpy(g_stpcpy(g_stpcpy(detailed_signal, "item-changed::"), prefix), "/min"); basic_layer->min_id = connect_swapped_after(layer->data, detailed_signal, gwy_layer_basic_min_max_changed, layer); strcpy(detailed_signal + len, "max"); basic_layer->max_id = connect_swapped_after(layer->data, detailed_signal, gwy_layer_basic_min_max_changed, layer); }
/** * gwy_math_sym_matrix_invert: * @n: Matrix size. * @a: Lower-left part of symmetric, positive definite matrix. * * Inverts a positive definite matrix in place. * * Returns: Whether the matrix invesion succeeded. **/ static gboolean gwy_math_sym_matrix_invert(gint n, gdouble *a) { gint q = 0, m; gdouble s, t; gdouble *x; gint k, i, j; x = g_newa(gdouble, n); for (k = n-1; k >= 0; k--) { s = a[0]; if (s <= 0) return FALSE; m = 0; for (i = 0; i < n-1; i++) { q = m+1; m += i+2; t = a[q]; x[i] = -t/s; /* note use temporary x */ if (i >= k) x[i] = -x[i]; for (j = q; j < m; j++) a[j - (i+1)] = a[j+1] + t * x[j - q]; } a[m] = 1.0/s; for (i = 0; i < n-1; i++) a[q + i] = x[i]; } return TRUE; }
static void _fill_file_md5(const gchar *filename, gint filelen, guint8 *md5) { FILE *fp; guint8 *buffer; size_t wc; const gint QQ_MAX_FILE_MD5_LENGTH = 10002432; g_return_if_fail(filename != NULL && md5 != NULL); if (filelen > QQ_MAX_FILE_MD5_LENGTH) filelen = QQ_MAX_FILE_MD5_LENGTH; fp = g_fopen(filename, "rb"); g_return_if_fail(fp != NULL); buffer = g_newa(guint8, filelen); g_return_if_fail(buffer != NULL); wc = fread(buffer, filelen, 1, fp); fclose(fp); if (wc != 1) { purple_debug_error("qq", "Unable to read file: %s\n", filename); /* TODO: XXX: Really, the caller should be modified to deal with this properly. */ return; } qq_get_md5(md5, QQ_KEY_LENGTH, buffer, filelen); }
/* parse the return of keep-alive packet, it includes some system information */ void qq_process_keep_alive_reply(guint8 *buf, gint buf_len, GaimConnection *gc) { qq_data *qd; gint len; gchar **segments; guint8 *data; g_return_if_fail(buf != NULL && buf_len != 0); qd = (qq_data *) gc->proto_data; len = buf_len; data = g_newa(guint8, len); if (qq_crypt(DECRYPT, buf, buf_len, qd->session_key, data, &len)) { /* the last one is 60, don't know what it is */ if (NULL == (segments = split_data(data, len, "\x1f", 6))) return; /* segments[0] and segment[1] are all 0x30 ("0") */ qd->all_online = strtol(segments[2], NULL, 10); if(0 == qd->all_online) gaim_connection_error(gc, _("Keep alive error, seems connection lost!")); g_free(qd->my_ip); qd->my_ip = g_strdup(segments[3]); qd->my_port = strtol(segments[4], NULL, 10); g_strfreev(segments); } else gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Error decrypt keep alive reply\n"); /* we refresh buddies's online status periodically */ /* qd->last_get_online is updated when setting get_buddies_online packet */ if ((time(NULL) - qd->last_get_online) >= QQ_UPDATE_ONLINE_INTERVAL) qq_send_packet_get_buddies_online(gc, QQ_FRIENDS_ONLINE_POSITION_START); }
/* set seq and is_save2trans, then call send_cmd_detail */ gint qq_send_server_reply(PurpleConnection *gc, guint16 cmd, guint16 seq, guint8 *data, gint data_len) { qq_data *qd; guint8 *encrypted; gint encrypted_len; gint bytes_sent; g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1); qd = (qq_data *)gc->proto_data; g_return_val_if_fail(data != NULL && data_len > 0, -1); #if 1 purple_debug_info("QQ", "<== [SRV-%05d] %s(0x%04X), datalen %d\n", seq, qq_get_cmd_desc(cmd), cmd, data_len); #endif /* at most 17 bytes more */ encrypted = g_newa(guint8, data_len + 17); encrypted_len = qq_encrypt(encrypted, data, data_len, qd->session_key); if (encrypted_len < 16) { purple_debug_error("QQ_ENCRYPT", "Error len %d: [%05d] 0x%04X %s\n", encrypted_len, seq, cmd, qq_get_cmd_desc(cmd)); return -1; } bytes_sent = packet_send_out(gc, cmd, seq, encrypted, encrypted_len); qq_trans_add_server_reply(gc, cmd, seq, encrypted, encrypted_len); return bytes_sent; }
/* data has been encrypted before */ static gint packet_send_out(PurpleConnection *gc, guint16 cmd, guint16 seq, guint8 *data, gint data_len) { qq_data *qd; guint8 *buf; gint buf_len; gint bytes_sent; g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1); qd = (qq_data *)gc->proto_data; g_return_val_if_fail(data != NULL && data_len > 0, -1); buf = g_newa(guint8, MAX_PACKET_SIZE); memset(buf, 0, MAX_PACKET_SIZE); /* encapsulate */ buf_len = packet_encap(qd, buf, MAX_PACKET_SIZE, cmd, seq, data, data_len); if (buf_len <= 0) { return -1; } qd->net_stat.sent++; if (qd->use_tcp) { bytes_sent = tcp_send_out(gc, buf, buf_len); } else { bytes_sent = udp_send_out(gc, buf, buf_len); } return bytes_sent; }
static gint server_buddy_check_code(PurpleConnection *gc, gchar *from, guint8 *data, gint data_len) { gint bytes; guint16 code_len; guint8 *code; g_return_val_if_fail(data != NULL && data_len > 0, 0); bytes = 0; bytes += qq_get16(&code_len, data + bytes); if (code_len <= 0) { purple_debug_info("QQ", "Server msg for buddy has no code\n"); return bytes; } if (bytes + code_len < data_len) { purple_debug_error("QQ", "Code len error in server msg for buddy\n"); qq_show_packet("server_buddy_check_code", data, data_len); code_len = data_len - bytes; } code = g_newa(guint8, code_len); bytes += qq_getdata(code, code_len, data + bytes); request_buddy_check_code(gc, from, code, code_len); return bytes; }
static gint _qq_send_file(PurpleConnection *gc, guint8 *data, gint len, guint16 packet_type, guint32 to_uid) { guint8 *raw_data; gint bytes = 0; guint32 file_key; qq_data *qd; qd = (qq_data *) gc->proto_data; raw_data = g_newa(guint8, MAX_PACKET_SIZE); file_key = _gen_file_key(); bytes += qq_put8(raw_data + bytes, packet_type); bytes += qq_put16(raw_data + bytes, qd->client_tag); bytes += qq_put8(raw_data + bytes, file_key & 0xff); bytes += qq_put32(raw_data + bytes, _encrypt_qq_uid(qd->uid, file_key)); bytes += qq_put32(raw_data + bytes, _encrypt_qq_uid(to_uid, file_key)); bytes += qq_putdata(raw_data + bytes, data, len); if (bytes == len + 12) { _qq_xfer_write(raw_data, bytes, qd->xfer); } else purple_debug_info("QQ", "send_file: want %d but got %d\n", len + 12, bytes); return bytes; }
static void _qq_send_file_progess(PurpleConnection *gc) { qq_data *qd = (qq_data *) gc->proto_data; PurpleXfer *xfer = qd->xfer; ft_info *info = (ft_info *) xfer->data; guint32 mask; guint8 *buffer; guint i; gint readbytes; if (purple_xfer_get_bytes_remaining(xfer) <= 0) return; if (info->window == 0 && info->max_fragment_index == 0) { if (_qq_xfer_open_file(purple_xfer_get_local_filename(xfer), "rb", xfer) == -1) { purple_xfer_cancel_local(xfer); return; } } buffer = g_newa(guint8, info->fragment_len); mask = 0x1 << (info->max_fragment_index % sizeof(info->window)); for (i = 0; i < sizeof(info->window); i++) { if ((info->window & mask) == 0) { readbytes = _qq_xfer_read_file(buffer, info->max_fragment_index + i, info->fragment_len, xfer); if (readbytes > 0) _qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_DATA_INFO, info->max_fragment_index + i + 1, 0, buffer, readbytes); } if (mask & 0x8000) mask = 0x0001; else mask = mask << 1; } }
/* Encrypt data with session_key, and send packet out */ static gint send_cmd_detail(PurpleConnection *gc, guint16 cmd, guint16 seq, guint8 *data, gint data_len, gboolean is_save2trans, UPDCLS update_class, guint32 ship32) { qq_data *qd; guint8 *encrypted; gint encrypted_len; gint bytes_sent; g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, -1); qd = (qq_data *)gc->proto_data; g_return_val_if_fail(data != NULL && data_len > 0, -1); /* at most 17 bytes more */ encrypted = g_newa(guint8, data_len + 17); encrypted_len = qq_encrypt(encrypted, data, data_len, qd->session_key); if (encrypted_len < 16) { purple_debug_error("QQ_ENCRYPT", "Error len %d: [%05d] 0x%04X %s\n", encrypted_len, seq, cmd, qq_get_cmd_desc(cmd)); return -1; } bytes_sent = packet_send_out(gc, cmd, seq, encrypted, encrypted_len); if (is_save2trans) { qq_trans_add_client_cmd(gc, cmd, seq, encrypted, encrypted_len, update_class, ship32); } return bytes_sent; }
static void gwy_layer_basic_get_fixed_range(GwyLayerBasic *basic_layer, GwyContainer *container, GwyDataField *data_field, gdouble *rmin, gdouble *rmax) { const gchar *prefix; gchar *key; guint len; if (!basic_layer->fixed_key) { gwy_data_field_get_min_max(data_field, rmin, rmax); return; } prefix = g_quark_to_string(basic_layer->fixed_key); len = strlen(prefix); key = g_newa(gchar, len + sizeof("/min")); g_stpcpy(g_stpcpy(key, prefix), "/min"); if (!gwy_container_gis_double_by_name(container, key, rmin)) *rmin = gwy_data_field_get_min(data_field); strcpy(key + len + 1, "max"); if (!gwy_container_gis_double_by_name(container, key, rmax)) *rmax = gwy_data_field_get_max(data_field); }
void qq_request_get_buddies_level(PurpleConnection *gc, guint32 update_class) { qq_data *qd = (qq_data *) gc->proto_data; PurpleBuddy *buddy; qq_buddy_data *bd; guint8 *buf; GSList *buddies, *it; gint bytes; /* server only reply levels for online buddies */ buf = g_newa(guint8, MAX_PACKET_SIZE); bytes = 0; bytes += qq_put8(buf + bytes, 0x00); buddies = purple_find_buddies(purple_connection_get_account(gc), NULL); for (it = buddies; it; it = it->next) { buddy = it->data; if (buddy == NULL) continue; if (buddy->proto_data == NULL) continue; bd = (qq_buddy_data *)buddy->proto_data; if (bd->uid == 0) continue; /* keep me as end of packet*/ if (bd->uid == qd->uid) continue; bytes += qq_put32(buf + bytes, bd->uid); } bytes += qq_put32(buf + bytes, qd->uid); qq_send_cmd_mess(gc, QQ_CMD_GET_LEVEL, buf, bytes, update_class, 0); }
static EventdEventsEvent * _eventd_events_get_event(EventdEvents *self, EventdEvent *event, GQuark *current_flags) { const gchar *category, *name; gsize s; GList *list; EventdEventsEvent *match; category = eventd_event_get_category(event); name = eventd_event_get_name(event); s = strlen(category) + strlen(name) + 2; gchar *full_name = g_newa(gchar, s); g_snprintf(full_name, s, "%s %s", category, name); list = g_hash_table_lookup(self->events, full_name); if ( list != NULL ) { match = _eventd_events_get_best_match(list, event, current_flags); if ( match != NULL ) return match; } list = g_hash_table_lookup(self->events, category); if ( list != NULL ) { match = _eventd_events_get_best_match(list, event, current_flags); if ( match != NULL ) return match; } return NULL; }
static void descriptor_check_consistency (Descriptor *desc, gboolean print) { int count = desc->anchor.data.count; int max_count = LOCK_FREE_ALLOC_SB_USABLE_SIZE (desc->block_size) / desc->slot_size; gboolean* linked = g_newa (gboolean, max_count); int i, last; unsigned int index; #ifndef DESC_AVAIL_DUMMY Descriptor *avail; for (avail = desc_avail; avail; avail = avail->next) g_assert_OR_PRINT (desc != avail, "descriptor is in the available list\n"); #endif g_assert_OR_PRINT (desc->slot_size == desc->heap->sc->slot_size, "slot size doesn't match size class\n"); if (print) g_print ("descriptor %p is ", desc); switch (desc->anchor.data.state) { case STATE_FULL: if (print) g_print ("full\n"); g_assert_OR_PRINT (count == 0, "count is not zero: %d\n", count); break; case STATE_PARTIAL: if (print) g_print ("partial\n"); g_assert_OR_PRINT (count < max_count, "count too high: is %d but must be below %d\n", count, max_count); break; case STATE_EMPTY: if (print) g_print ("empty\n"); g_assert_OR_PRINT (count == max_count, "count is wrong: is %d but should be %d\n", count, max_count); break; default: g_assert_OR_PRINT (FALSE, "invalid state\n"); } for (i = 0; i < max_count; ++i) linked [i] = FALSE; index = desc->anchor.data.avail; last = -1; for (i = 0; i < count; ++i) { gpointer addr = (char*)desc->sb + index * desc->slot_size; g_assert_OR_PRINT (index >= 0 && index < max_count, "index %d for %dth available slot, linked from %d, not in range [0 .. %d)\n", index, i, last, max_count); g_assert_OR_PRINT (!linked [index], "%dth available slot %d linked twice\n", i, index); if (linked [index]) break; linked [index] = TRUE; last = index; index = *(unsigned int*)addr; } }
/** * gtk_distribute_natural_allocation: * @extra_space: Extra space to redistribute among children after subtracting * minimum sizes and any child padding from the overall allocation * @n_requested_sizes: Number of requests to fit into the allocation * @sizes: An array of structs with a client pointer and a minimum/natural size * in the orientation of the allocation. * * Distributes @extra_space to child @sizes by bringing smaller * children up to natural size first. * * The remaining space will be added to the @minimum_size member of the * GtkRequestedSize struct. If all sizes reach their natural size then * the remaining space is returned. * * Returns: The remainder of @extra_space after redistributing space * to @sizes. */ gint gtk_distribute_natural_allocation (gint extra_space, guint n_requested_sizes, GtkRequestedSize *sizes) { guint *spreading; gint i; g_return_val_if_fail (extra_space >= 0, 0); spreading = g_newa (guint, n_requested_sizes); for (i = 0; i < n_requested_sizes; i++) spreading[i] = i; /* Distribute the container's extra space c_gap. We want to assign * this space such that the sum of extra space assigned to children * (c^i_gap) is equal to c_cap. The case that there's not enough * space for all children to take their natural size needs some * attention. The goals we want to achieve are: * * a) Maximize number of children taking their natural size. * b) The allocated size of children should be a continuous * function of c_gap. That is, increasing the container size by * one pixel should never make drastic changes in the distribution. * c) If child i takes its natural size and child j doesn't, * child j should have received at least as much gap as child i. * * The following code distributes the additional space by following * these rules. */ /* Sort descending by gap and position. */ g_qsort_with_data (spreading, n_requested_sizes, sizeof (guint), compare_gap, sizes); /* Distribute available space. * This master piece of a loop was conceived by Behdad Esfahbod. */ for (i = n_requested_sizes - 1; extra_space > 0 && i >= 0; --i) { /* Divide remaining space by number of remaining children. * Sort order and reducing remaining space by assigned space * ensures that space is distributed equally. */ gint glue = (extra_space + i) / (i + 1); gint gap = sizes[(spreading[i])].natural_size - sizes[(spreading[i])].minimum_size; gint extra = MIN (glue, gap); sizes[spreading[i]].minimum_size += extra; extra_space -= extra; } return extra_space; }
WatchTreeRemoveResult watch_tree_remove (WatchTree *tree, const gchar *path, gpointer data) { WatchTree *root_node = (WatchTree *) tree; WatchTreeRemoveResult result; GSList *backtrack; WatchTree *node; StringRef ref; /* '/' */ node = root_node; ref.str = (gchar *) path; ref.len = 1; backtrack = NULL; while (ref.str[ref.len]) { GSList *tmp = g_newa (GSList, 1); tmp->data = node; tmp->next = backtrack; backtrack = tmp; ref.str += ref.len; ref.len = strcspn (ref.str, "/"); if (ref.str[ref.len] == '/') ref.len++; node = tree_node_get_child (node, &ref, FALSE); g_assert (node != NULL); } node->watchers = g_slist_remove (node->watchers, data); if (node->watchers != NULL) /* nothing changes */ result = WATCH_TREE_REMOVE_RESULT_NONE; else if (node->children && g_hash_table_size (node->children)) /* there are still child watches, so we have to check */ result = WATCH_TREE_REMOVE_RESULT_SOME; else /* no watchers and no child watches -- remove all */ result = WATCH_TREE_REMOVE_RESULT_ALL; while (node->watchers == NULL && (!node->children || g_hash_table_size (node->children)) == 0 && backtrack) { WatchTree *parent = backtrack->data; g_hash_table_remove (parent->children, node); backtrack = backtrack->next; node = parent; } return result; }
gboolean peas_lua_utils_check_version (lua_State *L, guint req_major, guint req_minor, guint req_micro) { const gchar *version_str; gchar **version_str_parts; gint n_version_parts; gint64 *version_parts; gint i; gboolean success = FALSE; lua_getfield (L, -1, "_VERSION"); version_str = lua_tostring (L, -1); version_str_parts = g_strsplit (version_str, ".", 0); n_version_parts = g_strv_length (version_str_parts); version_parts = g_newa (gint64, n_version_parts); for (i = 0; i < n_version_parts; ++i) { gchar *end; version_parts[i] = g_ascii_strtoll (version_str_parts[i], &end, 10); if (*end != '\0' || version_parts[i] < 0 || version_parts[i] == G_MAXINT64) { g_warning ("Invalid version string: %s", version_str); goto error; } } if (n_version_parts < 3 || version_parts[0] != req_major || version_parts[1] < req_minor || (version_parts[1] == req_minor && version_parts[2] < req_micro)) { g_warning ("Version mismatch %d.%d.%d is required, found %s", req_major, req_minor, req_micro, version_str); goto error; } success = TRUE; error: /* Pop _VERSION */ lua_pop (L, 1); g_strfreev (version_str_parts); return success; }
static void _qq_update_send_progess(PurpleConnection *gc, guint32 fragment_index) { guint32 mask; guint8 *buffer; gint readbytes; qq_data *qd = (qq_data *) gc->proto_data; PurpleXfer *xfer = qd->xfer; ft_info *info = (ft_info *) xfer->data; purple_debug_info("QQ", "receiving %dth fragment ack, slide window status %o, max_fragment_index %d\n", fragment_index, info->window, info->max_fragment_index); if (fragment_index < info->max_fragment_index || fragment_index >= info->max_fragment_index + sizeof(info->window)) { purple_debug_info("QQ", "duplicate %dth fragment, drop it!\n", fragment_index+1); return; } mask = 0x1 << (fragment_index % sizeof(info->window)); if ((info->window & mask) == 0) { info->window |= mask; if (fragment_index + 1 != info->fragment_num) { xfer->bytes_sent += info->fragment_len; } else { xfer->bytes_sent += purple_xfer_get_size(xfer) % info->fragment_len; } xfer->bytes_remaining = purple_xfer_get_size(xfer) - purple_xfer_get_bytes_sent(xfer); purple_xfer_update_progress(xfer); if (purple_xfer_get_bytes_remaining(xfer) <= 0) { /* We have finished sending the file */ purple_xfer_set_completed(xfer, TRUE); return; } mask = 0x1 << (info->max_fragment_index % sizeof(info->window)); while (info->window & mask) { /* move the slide window */ info->window &= ~mask; buffer = g_newa(guint8, info->fragment_len); readbytes = _qq_xfer_read_file(buffer, info->max_fragment_index + sizeof(info->window), info->fragment_len, xfer); if (readbytes > 0) _qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_DATA_INFO, info->max_fragment_index + sizeof(info->window) + 1, 0, buffer, readbytes); info->max_fragment_index ++; if (mask & 0x8000) mask = 0x0001; else mask = mask << 1; } } purple_debug_info("QQ", "procceed %dth fragment ack, slide window status %o, max_fragment_index %d\n", fragment_index, info->window, info->max_fragment_index); }
static GimpEevlQuantity gimp_eevl_factor (GimpEevl *eva) { GimpEevlQuantity evaluated_factor = { 0, 0 }; GimpEevlToken consumed_token; if (gimp_eevl_accept (eva, GIMP_EEVL_TOKEN_NUM, &consumed_token)) { evaluated_factor.value = consumed_token.value.fl; } else if (gimp_eevl_accept (eva, '(', NULL)) { evaluated_factor = gimp_eevl_expression (eva); gimp_eevl_expect (eva, ')', 0); } else { gimp_eevl_error (eva, "Expected number or '('"); } if (eva->current_token.type == GIMP_EEVL_TOKEN_IDENTIFIER) { gchar *identifier; GimpEevlQuantity result; gimp_eevl_accept (eva, GIMP_EEVL_TOKEN_ANY, &consumed_token); identifier = g_newa (gchar, consumed_token.value.size + 1); strncpy (identifier, consumed_token.value.c, consumed_token.value.size); identifier[consumed_token.value.size] = '\0'; if (eva->unit_resolver_proc (identifier, &result, eva->data)) { evaluated_factor.value /= result.value; evaluated_factor.dimension += result.dimension; } else { gimp_eevl_error (eva, "Unit was not resolved"); } } return evaluated_factor; }
/* send packet to get info for each group member */ gint qq_request_room_get_members_info( PurpleConnection *gc, guint32 room_id, guint32 update_class, guint32 index ) { guint8 *raw_data; gint bytes, num; GList *list; qq_room_data *rmd; qq_buddy_data *bd; guint32 i = 0; g_return_val_if_fail(room_id > 0, 0); rmd = qq_room_data_find(gc, room_id); g_return_val_if_fail(rmd != NULL, 0); for (num = 0, list = rmd->members; list != NULL; list = list->next) { bd = (qq_buddy_data *) list->data; if (check_update_interval(bd)) num++; } if (num <= 0) { purple_debug_info("QQ", "No group member info needs to be updated now.\n"); return 0; } raw_data = g_newa(guint8, 4 * num); bytes = 0; list = rmd->members; /* index shipped from last request send 30 uids one time */ while (list != NULL) { if (i>=index) { bd = (qq_buddy_data *) list->data; if (check_update_interval(bd)) bytes += qq_put32(raw_data + bytes, bd->uid); } i++; if (i==index+30) break; list = list->next; } /* if reach the end */ if (list == NULL) i=0; qq_send_room_cmd_mess(gc, QQ_ROOM_CMD_GET_MEMBERS_INFO, rmd->id, raw_data, bytes, update_class, i); return num; }
static GstFlowReturn gst_file_sink_render_list (GstBaseSink * bsink, GstBufferList * buffer_list) { GstFlowReturn flow; GstBuffer **buffers; GstFileSink *sink; guint8 *mem_nums; guint total_mems; guint i, num_buffers; gboolean sync_after = FALSE; sink = GST_FILE_SINK_CAST (bsink); num_buffers = gst_buffer_list_length (buffer_list); if (num_buffers == 0) goto no_data; /* extract buffers from list and count memories */ buffers = g_newa (GstBuffer *, num_buffers); mem_nums = g_newa (guint8, num_buffers); for (i = 0, total_mems = 0; i < num_buffers; ++i) { buffers[i] = gst_buffer_list_get (buffer_list, i); mem_nums[i] = gst_buffer_n_memory (buffers[i]); total_mems += mem_nums[i]; if (GST_BUFFER_FLAG_IS_SET (buffers[i], GST_BUFFER_FLAG_SYNC_AFTER)) sync_after = TRUE; } flow = gst_file_sink_render_buffers (sink, buffers, num_buffers, mem_nums, total_mems); if (flow == GST_FLOW_OK && sync_after) { if (fflush (sink->file) || fsync (fileno (sink->file))) { GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, (_("Error while writing to file \"%s\"."), sink->filename), ("%s", g_strerror (errno))); flow = GST_FLOW_ERROR; } } return flow; no_data: { GST_LOG_OBJECT (sink, "empty buffer list"); return GST_FLOW_OK; } }
static void fit_plot_curve(FitArgs *args) { GwyGraphCurveModel *cmodel; gdouble *xd, *yd; gboolean initial, ok; /* XXX: ignored */ gint i, n; gdouble *param; if (!args->is_fitted && !args->is_estimated) return; initial = !args->is_fitted; n = gwy_nlfit_preset_get_nparams(args->fitfunc); param = g_newa(gdouble, n); for (i = 0; i < n; i++) { FitParamArg *arg; arg = &g_array_index(args->param, FitParamArg, i); param[i] = initial ? arg->init : arg->value; } n = gwy_data_line_get_res(args->xdata); g_return_if_fail(n == gwy_data_line_get_res(args->ydata)); xd = gwy_data_line_get_data(args->xdata); yd = gwy_data_line_get_data(args->ydata); for (i = 0; i < n; i++) yd[i] = gwy_nlfit_preset_get_value(args->fitfunc, xd[i], param, &ok); if (gwy_graph_model_get_n_curves(args->graph_model) == 2) cmodel = gwy_graph_model_get_curve(args->graph_model, 1); else { cmodel = gwy_graph_curve_model_new(); g_object_set(cmodel, "mode", GWY_GRAPH_CURVE_LINE, "color", &args->fitcolor, NULL); gwy_graph_model_add_curve(args->graph_model, cmodel); g_object_unref(cmodel); } g_object_set(cmodel, "description", initial ? gwy_sgettext("Estimate") : gwy_sgettext("Fit"), NULL); gwy_graph_curve_model_set_data(cmodel, xd, yd, n); }