void group_entry_execute(struct group_entry *entry, struct packet *packet) { VLOG_DBG_RL(LOG_MODULE, &rl, "Executing group %u.", entry->stats->group_id); /* NOTE: Packet is copied for all buckets now (even if there is only one). * This allows execution of the original packet onward. It is not clear * whether that is allowed or not according to the spec. though. */ switch (entry->desc->type) { case (OFPGT_ALL): { execute_all(entry, packet); break; } case (OFPGT_SELECT): { execute_select(entry, packet); break; } case (OFPGT_INDIRECT): { execute_indirect(entry, packet); break; } case (OFPGT_FF): { execute_ff(entry, packet); break; } default: { VLOG_WARN_RL(LOG_MODULE, &rl, "Trying to execute unknown group type (%u) in group (%u).", entry->desc->type, entry->stats->group_id); } } }
/** * Get a random item for replication. Returns a single, not expired, * random item from those with the highest replication counters. The * item's replication counter is decremented by one IF it was positive * before. Call 'proc' with all values ZERO or NULL if the datastore * is empty. * * @param cls closure * @param proc function to call the value (once only). * @param proc_cls closure for proc */ static void mysql_plugin_get_replication (void *cls, PluginDatumProcessor proc, void *proc_cls) { struct Plugin *plugin = cls; struct ReplCtx rc; unsigned long long rvalue; unsigned long repl; MYSQL_BIND results; rc.plugin = plugin; rc.proc = proc; rc.proc_cls = proc_cls; memset (&results, 0, sizeof (results)); results.buffer_type = MYSQL_TYPE_LONG; results.buffer = &repl; results.is_unsigned = GNUNET_YES; if (1 != GNUNET_MYSQL_statement_run_prepared_select (plugin->mc, plugin->max_repl, 1, &results, NULL, NULL, -1)) { proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0); return; } rvalue = (unsigned long long) GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX); execute_select (plugin, plugin->select_replication, &repl_proc, &rc, MYSQL_TYPE_LONG, &repl, GNUNET_YES, MYSQL_TYPE_LONGLONG, &rvalue, GNUNET_YES, MYSQL_TYPE_LONG, &repl, GNUNET_YES, MYSQL_TYPE_LONGLONG, &rvalue, GNUNET_YES, -1); }
/** * Get a zero-anonymity datum from the datastore. * * @param cls our "struct Plugin*" * @param offset offset of the result * @param type entries of which type should be considered? * Use 0 for any type. * @param proc function to call on a matching value or NULL * @param proc_cls closure for iter */ static void mysql_plugin_get_zero_anonymity (void *cls, uint64_t offset, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls) { struct Plugin *plugin = cls; unsigned long long rvalue = (unsigned long long) GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX); execute_select (plugin, plugin->zero_iter, proc, proc_cls, MYSQL_TYPE_LONG, &type, GNUNET_YES, MYSQL_TYPE_LONGLONG, &rvalue, GNUNET_YES, MYSQL_TYPE_LONG, &type, GNUNET_YES, MYSQL_TYPE_LONGLONG, &rvalue, GNUNET_YES, -1); }
/** * Get a random item for expiration. * Call 'proc' with all values ZERO or NULL if the datastore is empty. * * @param cls closure * @param proc function to call the value (once only). * @param proc_cls closure for proc */ static void mysql_plugin_get_expiration (void *cls, PluginDatumProcessor proc, void *proc_cls) { struct Plugin *plugin = cls; long long nt; struct ExpiCtx rc; rc.plugin = plugin; rc.proc = proc; rc.proc_cls = proc_cls; nt = (long long) GNUNET_TIME_absolute_get ().abs_value_us; execute_select (plugin, plugin->select_expiration, expi_proc, &rc, MYSQL_TYPE_LONGLONG, &nt, GNUNET_YES, -1); }
/** * Wrapper for the processor for 'mysql_plugin_get_expiration'. * If no expired value was found, we do a second query for * low-priority content. * * @param cls closure * @param key key for the content * @param size number of bytes in data * @param data content stored * @param type type of the content * @param priority priority of the content * @param anonymity anonymity-level for the content * @param expiration expiration time for the content * @param uid unique identifier for the datum; * maybe 0 if no unique identifier is available * * @return GNUNET_SYSERR to abort the iteration, GNUNET_OK to continue * (continue on call to "next", of course), * GNUNET_NO to delete the item and continue (if supported) */ static int expi_proc (void *cls, const struct GNUNET_HashCode * key, uint32_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, struct GNUNET_TIME_Absolute expiration, uint64_t uid) { struct ExpiCtx *rc = cls; struct Plugin *plugin = rc->plugin; if (NULL == key) { execute_select (plugin, plugin->select_priority, rc->proc, rc->proc_cls, -1); return GNUNET_SYSERR; } return rc->proc (rc->proc_cls, key, size, data, type, priority, anonymity, expiration, uid); }
int sqlcli( int aArg1 ) { SQLRETURN rc; SQLHENV env; // Environment Handle SQLHDBC dbc; // Connection Handle int conn_flag; env = SQL_NULL_HENV; dbc = SQL_NULL_HDBC; conn_flag = 0; /* allocate handle */ rc = alloc_handle(env, dbc); if ( rc != SQL_SUCCESS ) { free_handle(env, dbc, conn_flag); exit(1); } /* Connect to Altibase Server */ rc = db_connect(dbc, conn_flag); if ( rc != SQL_SUCCESS ) { free_handle(env, dbc, conn_flag); exit(1); } /* select data */ rc = execute_select(dbc); if ( rc != SQL_SUCCESS ) { free_handle(env, dbc, conn_flag); exit(1); } /* disconnect, free handles */ free_handle(env, dbc, conn_flag); }
void _gda_postgres_compute_types (GdaConnection *cnc, GdaPostgresReuseable *rdata) { if (rdata->types_oid_hash) return; rdata->types_oid_hash = g_hash_table_new_full (g_int_hash, g_int_equal, NULL, (GDestroyNotify) gda_postgres_type_oid_free); rdata->types_dbtype_hash = g_hash_table_new (g_str_hash, g_str_equal); GdaDataModel *model, *model_avoid, *model_anyoid = NULL; gint ncols, nrows, i; gchar *avoid_types = NULL; GString *string; if (rdata->version_float == 0) _gda_postgres_compute_version (cnc, rdata, NULL); if (rdata->version_float < 7.3) { gchar *query; avoid_types = "'SET', 'cid', 'oid', 'int2vector', 'oidvector', 'regproc', 'smgr', 'tid', 'unknown', 'xid'"; /* main query to fetch infos about the data types */ query = g_strdup_printf ("SELECT pg_type.oid, typname, usename, obj_description(pg_type.oid) " "FROM pg_type, pg_user " "WHERE typowner=usesysid AND typrelid = 0 AND typname !~ '^_' " "AND typname not in (%s) " "ORDER BY typname", avoid_types); model = execute_select (cnc, rdata, query); g_free (query); /* query to fetch non returned data types */ query = g_strdup_printf ("SELECT pg_type.oid FROM pg_type WHERE typname in (%s)", avoid_types); model_avoid = execute_select (cnc, rdata, query); g_free (query); } else { gchar *query; avoid_types = "'any', 'anyarray', 'anyelement', 'cid', 'cstring', 'int2vector', 'internal', 'language_handler', 'oidvector', 'opaque', 'record', 'refcursor', 'regclass', 'regoper', 'regoperator', 'regproc', 'regprocedure', 'regtype', 'SET', 'smgr', 'tid', 'trigger', 'unknown', 'void', 'xid'"; /* main query to fetch infos about the data types */ query = g_strdup_printf ( "SELECT t.oid, t.typname, u.usename, pg_catalog.obj_description(t.oid), t.typinput " "FROM pg_catalog.pg_type t LEFT JOIN pg_catalog.pg_user u ON (t.typowner=u.usesysid), pg_catalog.pg_namespace n " "WHERE n.oid = t.typnamespace " "AND pg_catalog.pg_type_is_visible(t.oid) " /*--AND (n.nspname = 'public' OR n.nspname = 'pg_catalog')*/ "AND typname !~ '^_' " "AND (t.typrelid = 0 OR " "(SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)) " "AND t.typname not in (%s) " "ORDER BY typname", avoid_types); model = execute_select (cnc, rdata, query); g_free (query); /* query to fetch non returned data types */ query = g_strdup_printf ("SELECT t.oid FROM pg_catalog.pg_type t WHERE t.typname in (%s)", avoid_types); model_avoid = execute_select (cnc, rdata, query); g_free (query); /* query to fetch the oid of the 'any' data type */ model_anyoid = execute_select (cnc, rdata, "SELECT t.oid FROM pg_catalog.pg_type t WHERE t.typname = 'any'"); } if (rdata->version_float == 0) _gda_postgres_compute_version (cnc, rdata, NULL); if (!model || !model_avoid || ((rdata->version_float >= 7.3) && !model_anyoid)) { if (model) g_object_unref (model); if (model_avoid) g_object_unref (model_avoid); if (model_anyoid) g_object_unref (model_anyoid); return; } /* Data types returned to the Gda client */ nrows = gda_data_model_get_n_rows (model); ncols = gda_data_model_get_n_columns (model); if (nrows == 0) g_warning ("PostgreSQL provider did not find any data type (expect some mis-behaviours) please report the error to bugzilla.gnome.org"); for (i = 0; i < nrows; i++) { const GValue *conv_func_name = NULL; const GValue *values[4]; gint j; gboolean allread = TRUE; if (ncols >= 5) conv_func_name = gda_data_model_get_value_at (model, 4, i, NULL); for (j = 0; j < 4; j++) { values[j] = gda_data_model_get_value_at (model, j, i, NULL); if (!values [j]) { allread = FALSE; break; } } if (allread && (G_VALUE_TYPE (values[1]) == G_TYPE_STRING)) { GdaPostgresTypeOid *td; td = g_new0 (GdaPostgresTypeOid, 1); td->name = g_value_dup_string (values [1]); td->oid = (guint) g_ascii_strtoull (g_value_get_string (values[0]), NULL, 10); td->type = postgres_name_to_g_type (td->name, conv_func_name ? g_value_get_string (conv_func_name) : NULL); if (G_VALUE_TYPE (values[3]) == G_TYPE_STRING) td->comments = g_value_dup_string (values [3]); if (G_VALUE_TYPE (values[2]) == G_TYPE_STRING) td->owner = g_value_dup_string (values [2]); g_hash_table_insert (rdata->types_oid_hash, &(td->oid), td); g_hash_table_insert (rdata->types_dbtype_hash, &(td->name), td); } } /* Make a string of data types internal to postgres and not returned, for future queries */ string = NULL; nrows = gda_data_model_get_n_rows (model_avoid); for (i = 0; i < nrows; i++) { const GValue *cvalue; cvalue = gda_data_model_get_value_at (model_avoid, 0, i, NULL); if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING)) { if (!string) string = g_string_new (g_value_get_string (cvalue)); else { g_string_append (string, ", "); g_string_append (string, g_value_get_string (cvalue)); } } } rdata->avoid_types = avoid_types; if (string) rdata->avoid_types_oids = g_string_free (string, FALSE); g_object_unref (model); g_object_unref (model_avoid); /* make a string of the oid of type 'any' */ rdata->any_type_oid = NULL; if (model_anyoid) { if (gda_data_model_get_n_rows (model_anyoid) == 1) { const GValue *cvalue; cvalue = gda_data_model_get_value_at (model_anyoid, 0, 0, NULL); if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING)) rdata->any_type_oid = g_value_dup_string (cvalue); } g_object_unref (model_anyoid); } }
/** * Get one of the results for a particular key in the datastore. * * @param cls closure * @param offset offset of the result (modulo num-results); * specific ordering does not matter for the offset * @param key key to match, never NULL * @param vhash hash of the value, maybe NULL (to * match all values that have the right key). * Note that for DBlocks there is no difference * betwen key and vhash, but for other blocks * there may be! * @param type entries of which type are relevant? * Use 0 for any type. * @param proc function to call on the matching value, * with NULL for if no value matches * @param proc_cls closure for proc */ static void mysql_plugin_get_key (void *cls, uint64_t offset, const struct GNUNET_HashCode * key, const struct GNUNET_HashCode * vhash, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls) { struct Plugin *plugin = cls; int ret; MYSQL_BIND cbind[1]; long long total; unsigned long hashSize; unsigned long hashSize2; unsigned long long off; GNUNET_assert (key != NULL); GNUNET_assert (NULL != proc); hashSize = sizeof (struct GNUNET_HashCode); hashSize2 = sizeof (struct GNUNET_HashCode); memset (cbind, 0, sizeof (cbind)); total = -1; cbind[0].buffer_type = MYSQL_TYPE_LONGLONG; cbind[0].buffer = &total; cbind[0].is_unsigned = GNUNET_NO; if (type != 0) { if (vhash != NULL) { ret = GNUNET_MYSQL_statement_run_prepared_select (plugin->mc, plugin-> count_entry_by_hash_vhash_and_type, 1, cbind, NULL, NULL, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, MYSQL_TYPE_BLOB, vhash, hashSize2, &hashSize2, MYSQL_TYPE_LONG, &type, GNUNET_YES, -1); } else { ret = GNUNET_MYSQL_statement_run_prepared_select (plugin->mc, plugin->count_entry_by_hash_and_type, 1, cbind, NULL, NULL, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, MYSQL_TYPE_LONG, &type, GNUNET_YES, -1); } } else { if (vhash != NULL) { ret = GNUNET_MYSQL_statement_run_prepared_select (plugin->mc, plugin->count_entry_by_hash_and_vhash, 1, cbind, NULL, NULL, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, MYSQL_TYPE_BLOB, vhash, hashSize2, &hashSize2, -1); } else { ret = GNUNET_MYSQL_statement_run_prepared_select (plugin->mc, plugin->count_entry_by_hash, 1, cbind, NULL, NULL, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, -1); } } if ((ret != GNUNET_OK) || (0 >= total)) { proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0); return; } offset = offset % total; off = (unsigned long long) offset; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Obtaining %llu/%lld result for GET `%s'\n", off, total, GNUNET_h2s (key)); if (type != GNUNET_BLOCK_TYPE_ANY) { if (NULL != vhash) { execute_select (plugin, plugin->select_entry_by_hash_vhash_and_type, proc, proc_cls, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, MYSQL_TYPE_BLOB, vhash, hashSize, &hashSize, MYSQL_TYPE_LONG, &type, GNUNET_YES, MYSQL_TYPE_LONGLONG, &off, GNUNET_YES, -1); } else { execute_select (plugin, plugin->select_entry_by_hash_and_type, proc, proc_cls, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, MYSQL_TYPE_LONG, &type, GNUNET_YES, MYSQL_TYPE_LONGLONG, &off, GNUNET_YES, -1); } } else { if (NULL != vhash) { execute_select (plugin, plugin->select_entry_by_hash_and_vhash, proc, proc_cls, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, MYSQL_TYPE_BLOB, vhash, hashSize, &hashSize, MYSQL_TYPE_LONGLONG, &off, GNUNET_YES, -1); } else { execute_select (plugin, plugin->select_entry_by_hash, proc, proc_cls, MYSQL_TYPE_BLOB, key, hashSize, &hashSize, MYSQL_TYPE_LONGLONG, &off, GNUNET_YES, -1); } } }