static struct event_entry* aic_init_driver(void)
{
struct aic_entry *e = calloc(1, sizeof(struct aic_entry));
if (e == NULL) return NULL;
NEOERR *err;
e->base.name = (unsigned char*)strdup(PLUGIN_NAME);
e->base.ksize = strlen(PLUGIN_NAME);
e->base.process_driver = aic_process_driver;
e->base.stop_driver = aic_stop_driver;
char *dbsn = hdf_get_value(g_cfg, CONFIG_PATH".dbsn", NULL);
err = mdb_init(&e->db, dbsn);
JUMP_NOK(err, error);
e->cd = cache_create(hdf_get_int_value(g_cfg, CONFIG_PATH".numobjs", 1024), 0);
if (e->cd == NULL) {
wlog("init cache failure");
goto error;
}
return (struct event_entry*)e;
error:
if (e->base.name) free(e->base.name);
if (e->db) mdb_destroy(e->db);
if (e->cd) cache_free(e->cd);
free(e);
return NULL;
}
main(int argc, char **argv)
{
int rows;
int i;
unsigned char buf[2048];
MdbHandle *mdb;
MdbCatalogEntry entry;
#if 0
if (argc<2) {
fprintf(stderr,"Usage: %s <file> <table>\n",argv[0]);
exit(1);
}
mdb_init();
mdb = mdb_open(argv[1]);
mdb_read_pg(mdb, MDB_CATALOG_PG);
rows = mdb_catalog_rows(mdb);
for (i=0;i<rows;i++) {
if (mdb_read_catalog_entry(mdb, i, &entry)) {
if (!strcmp(entry.object_name,argv[2])) {
mdb_kkd_dump(&entry);
}
}
}
mdb_free_handle(mdb);
mdb_exit();
#endif
exit(0);
}
int main()
{
CGI *cgi;
NEOERR *err;
int ret;
//sleep(20);
mtc_init(TC_ROOT"login");
mconfig_parse_file(SITE_CONFIG, &g_cfg);
err = cgi_init(&cgi, NULL);
DIE_NOK_CGI(err);
err = cgi_parse(cgi);
DIE_NOK_CGI(err);
mdb_conn *conn = NULL;
ret = mdb_init(&conn, DB_DSN);
mdb_opfinish_json(ret, cgi->hdf, conn);
ret = login_get(cgi, conn);
mdb_opfinish_json(ret, cgi->hdf, conn);
mjson_output_hdf(cgi->hdf, 0);
#ifdef DEBUG_HDF
hdf_write_file(cgi->hdf, TC_ROOT"hdf.login");
#endif
mdb_destroy(conn);
cgi_destroy(&cgi);
return 0;
}
int main(int argc, char *argv[])
{
GtkWidget *gmdb;
GnomeProgram *program;
#ifdef SQL
/* initialize the SQL engine */
sql = mdb_sql_init();
#endif
/* initialize MDB Tools library */
mdb_init();
/* Initialize GNOME */
/* Initialize gnome program */
program = gnome_program_init ("gmdb", "0.2",
LIBGNOMEUI_MODULE, argc, argv,
GNOME_PARAM_POPT_TABLE, NULL,
GNOME_PARAM_HUMAN_READABLE_NAME,
_("Gnome-MDB File Viewer"),
GNOME_PARAM_APP_DATADIR, DATADIR,
NULL);
//gnome_init ("gmdb", "0.2", argc, argv);
//app = gnome_app_new ("gmdb", "Gnome-MDB File Viewer");
glade_init();
/* load the interface */
mainwin_xml = glade_xml_new(GMDB_GLADEDIR "gmdb.glade", NULL, NULL);
/* connect the signals in the interface */
glade_xml_signal_autoconnect(mainwin_xml);
gmdb = glade_xml_get_widget (mainwin_xml, "gmdb");
gtk_signal_connect (GTK_OBJECT (gmdb), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
//gmdb_load_icons(mainwin_xml);
if (argc>1) {
gmdb_file_open(argv[1]);
} else {
gmdb_reset_widgets();
}
gmdb_load_recent_files();
gmdb_init_popups();
/* start the event loop */
gtk_main();
#ifdef SQL
/* free MDB Tools library */
mdb_sql_exit(sql);
#endif
mdb_exit();
return 0;
}
int
main(int argc, char **argv)
{
MdbHandle *mdb;
int print_mdbver = 0;
int opt;
/* setlocale (LC_ALL, ""); */
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
while ((opt=getopt(argc, argv, "M"))!=-1) {
switch (opt) {
case 'M':
print_mdbver = 1;
break;
default:
break;
}
}
if (print_mdbver) {
fprintf(stdout,"%s\n", MDB_FULL_VERSION);
if (argc-optind < 1) exit(0);
}
/*
** optind is now the position of the first non-option arg,
** see getopt(3)
*/
if (argc-optind < 1) {
fprintf(stderr,_("Usage: %s [-M] <file>\n"),argv[0]);
exit(1);
}
mdb_init();
if (!(mdb = mdb_open(argv[optind], MDB_NOFLAGS))) {
fprintf(stderr,_("Error: unable to open file %s\n"),argv[optind]);
mdb_exit();
exit(1);
}
if (IS_JET3(mdb)) {
printf("JET3\n");
} else if (IS_JET4(mdb)) {
printf("JET4\n");
} else {
printf(_("unknown database version\n"));
}
mdb_close(mdb);
mdb_exit();
exit(0);
}
int main(int argc, char **argv, char **envp)
{
CGI *cgi = NULL;
NEOERR *err;
mdb_conn *conn = NULL;
char *s, *u, *p, *r, *jcbk;
mtc_init("test");
mconfig_parse_file(SITE_CONFIG, &g_cfg);
if (mdb_init(&conn, DB_DSN) != MDB_ERR_NONE) {
mtc_err("init db error %s", mdb_get_errmsg(conn));
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
return 1;
}
err = cgi_init(&cgi, NULL);
if (err != STATUS_OK) {
mtc_err("init cgi error");
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("初始化错误");
return 1;
}
err = cgi_parse(cgi);
if (err != STATUS_OK) {
mtc_err("parse cgi error");
hdf_set_value(cgi->hdf, PRE_OUTPUT".errmsg", "初始化出错");
goto finish;
}
u = hdf_get_value(cgi->hdf, PRE_COOKIE".samuser", NULL);
s = hdf_get_value(cgi->hdf, PRE_COOKIE".samkey", NULL);
if (s && u) {
if (user_has_login(conn, u, s)) {
hdf_set_copy(cgi->hdf, PRE_OUTPUT".samuser", PRE_COOKIE".samuser");
hdf_set_copy(cgi->hdf, PRE_OUTPUT".samkey", PRE_COOKIE".samkey");
hdf_set_value(cgi->hdf, PRE_OUTPUT".rcode", "1");
goto finish;
}
}
hdf_set_value(cgi->hdf, PRE_OUTPUT".rcode", "2");
finish:
cgi_display(cgi, F_TPL_TEST);
cgi_destroy(&cgi);
mdb_destroy(conn);
return 0;
}
static EventEntry* city_init_driver(void)
{
struct city_entry *e = calloc(1, sizeof(struct city_entry));
if (e == NULL) return NULL;
NEOERR *err;
e->base.name = (unsigned char*)strdup(PLUGIN_NAME);
e->base.ksize = strlen(PLUGIN_NAME);
e->base.process_driver = city_process_driver;
e->base.stop_driver = city_stop_driver;
//mevent_add_timer(&e->base.timers, 60, true, hint_timer_up_term);
char *s = hdf_get_value(g_cfg, CONFIG_PATH".dbsn", NULL);
err = mdb_init(&e->db, s);
JUMP_NOK(err, error);
e->cd = cache_create(hdf_get_int_value(g_cfg, CONFIG_PATH".numobjs", 1024), 0);
if (e->cd == NULL) {
wlog("init cache failure");
goto error;
}
s = hdf_get_value(g_cfg, CONFIG_PATH".ipfile", "QQWry.Dat");
err = ne_load_file(s, (char**)&ips);
JUMP_NOK(err, error);
ipbgn = b2int(ips, 4);
ipend = b2int(ips+4, 4);
if (ipbgn < 0 || ipend < 0) {
wlog("%s format error", s);
goto error;
}
return (EventEntry*)e;
error:
if (e->base.name) free(e->base.name);
if (e->db) mdb_destroy(e->db);
if (e->cd) cache_free(e->cd);
if (ips) free(ips);
free(e);
return NULL;
}
int
main(int argc, char **argv)
{
MdbHandle *mdb;
MdbTableDef *table;
char *dot, *colname, *tabname;
char *sargname = NULL;
if (argc<2) {
fprintf(stderr,"Usage: %s <file> <table.column> [sargs]\n",argv[0]);
exit(1);
}
mdb_init();
mdb = mdb_open(argv[1], MDB_NOFLAGS);
dot = strchr(argv[2],'.');
if (argc>3) sargname = argv[3];
if (!dot) {
fprintf(stderr,"Usage: %s <file> <table.column> [sarg]\n",argv[0]);
exit(1);
}
tabname = argv[2];
*dot='\0';
colname = ++dot;
table = mdb_read_table_by_name(mdb, tabname, MDB_TABLE);
if (table) {
mdb_read_columns(table);
dump_ole(table, colname, sargname);
mdb_free_tabledef(table);
}
mdb_close(mdb);
mdb_exit();
exit(0);
}
static EventEntry* aux_init_driver(void)
{
struct aux_entry *e = calloc(1, sizeof(struct aux_entry));
if (e == NULL) return NULL;
NEOERR *err;
e->base.name = (unsigned char*)strdup(PLUGIN_NAME);
e->base.ksize = strlen(PLUGIN_NAME);
e->base.process_driver = aux_process_driver;
e->base.stop_driver = aux_stop_driver;
//mevent_add_timer(&e->base.timers, 60, true, hint_timer_up_term);
char *s = hdf_get_value(g_cfg, CONFIG_PATH".dbsn", NULL);
err = mdb_init(&e->db, s);
JUMP_NOK(err, error);
e->cd = cache_create(hdf_get_int_value(g_cfg, CONFIG_PATH".numobjs", 1024), 0);
if (e->cd == NULL) {
wlog("init cache failure");
goto error;
}
err = mdb_exec(e->db, NULL, "SELECT id from memory ORDER BY id DESC LIMIT 1", NULL);
JUMP_NOK(err, error);
err = mdb_get(e->db, "i", &m_memory_maxid);
if (nerr_handle(&err, NERR_NOT_FOUND)) {
mtc_err("table memory empty");
wlog("table memory empty");
}
JUMP_NOK(err, error);
return (EventEntry*)e;
error:
if (e->base.name) free(e->base.name);
if (e->db) mdb_destroy(e->db);
if (e->cd) cache_free(e->cd);
free(e);
return NULL;
}
main(int argc, char **argv)
{
MdbHandle *mdb;
MdbTableDef *table;
mdb_init();
if (!(mdb = mdb_open(MDB_FILE, MDB_NOFLAGS))) {
exit(1);
}
table = mdb_read_table_by_name(mdb, TABLE_NAME, MDB_TABLE);
if (table) {
print_table(table);
mdb_free_tabledef(table);
}
mdb_close(mdb);
mdb_exit();
exit(0);
}
bool mdb_t::open (
int count,
int size
)
{
try
{
m_buffers.reserve ( count );
for ( int i = 0; i < count; ++ i )
{
std::string * s = new std::string ();
s->resize ( MDB_VAL_LEN + 16 );
m_buffers.push_back ( s );
}
}
catch ( ... )
{
return false;
}
if ( size <= 0 )
{
m_ok = false;
return true;
}
if ( mdb_init ( size ) != 0 )
{
return false;
}
m_ok = true;
return true;
}
int
main(int argc, char **argv)
{
unsigned int i;
MdbHandle *mdb;
MdbCatalogEntry *entry;
int found = 0;
if (argc<3) {
fprintf(stderr,"Usage: %s <file> <table>\n",argv[0]);
exit(1);
}
mdb_init();
mdb = mdb_open(argv[1], MDB_NOFLAGS);
mdb_read_catalog(mdb, MDB_TABLE);
for (i=0;i<mdb->num_catalog;i++) {
entry = g_ptr_array_index(mdb->catalog,i);
if (entry->object_type == MDB_TABLE &&
!strcmp(entry->object_name,argv[2])) {
mdb_table_dump(entry);
found++;
}
}
if (!found) {
fprintf(stderr,"No table named %s found.\n", argv[2]);
}
mdb_close(mdb);
mdb_exit();
exit(0);
}
void smsalarm_msg(char *msg)
{
mdb_conn *db;
//char content[100];
NEOERR *err;
err = mdb_init(&db, SMSA_DB_SN);
RETURN_NOK(err);
HDF *node = hdf_get_obj(g_cfg, SMSA_CFG_PATH".leader");
if (node != NULL) node = hdf_obj_child(node);
while (node != NULL) {
//memset(content, 0x0, sizeof(content));
err = mdb_exec(db, NULL,
"INSERT INTO monitor_smssend (smsSendTo, smsContent) VALUES ('%s', '%s')",
NULL, hdf_obj_value(node), msg);
TRACE_NOK(err);
node = hdf_obj_next(node);
}
mdb_destroy(db);
}
main(int argc, char **argv)
{
int rows;
int i;
unsigned char buf[2048];
MdbHandle *mdb;
MdbCatalogEntry *entry;
MdbTableDef *table;
GList *l;
if (argc<2) {
fprintf(stderr,"Usage: %s <file> <table>\n",argv[0]);
exit(1);
}
mdb_init();
mdb = mdb_open(argv[1]);
mdb_read_catalog(mdb, MDB_TABLE);
for (i=0;i<mdb->num_catalog;i++) {
entry = g_ptr_array_index(mdb->catalog,i);
if (entry->object_type == MDB_TABLE &&
!strcmp(entry->object_name,argv[2])) {
table = mdb_read_table(entry);
mdb_read_columns(table);
mdb_data_dump(table);
}
}
mdb_free_handle(mdb);
mdb_exit();
exit(0);
}
int
main (int argc, char **argv)
{
unsigned int i, j, k;
unsigned int unsupported = 0;
MdbHandle *mdb;
MdbCatalogEntry *entry;
MdbTableDef *table;
MdbColumn *col;
FILE *typesfile;
FILE *headerfile;
FILE *cfile;
if (argc < 2) {
fprintf (stderr, "Usage: %s <file>\n",argv[0]);
exit (1);
}
mdb_init();
/* open the database */
mdb = mdb_open (argv[1], MDB_NOFLAGS);
if (!mdb) {
mdb_exit();
exit(1);
}
typesfile = fopen ("types.h", "w");
headerfile = fopen ("dumptypes.h", "w");
cfile = fopen ("dumptypes.c", "w");
copy_header (typesfile);
copy_header (headerfile);
fprintf (headerfile, "#include \"types.h\"\n");
copy_header (cfile);
fprintf (cfile, "#include <stdio.h>\n");
fprintf (cfile, "#include \"dumptypes.h\"\n");
/* read the catalog */
mdb_read_catalog (mdb, MDB_TABLE);
/* loop over each entry in the catalog */
for (i=0; i < mdb->num_catalog; i++)
{
entry = g_ptr_array_index (mdb->catalog, i);
if (!mdb_is_user_table(entry))
continue;
fprintf (typesfile, "typedef struct _%s\n", entry->object_name);
fprintf (typesfile, "{\n");
fprintf (headerfile, "void dump_%s (%s x);\n",
entry->object_name, entry->object_name);
fprintf (cfile, "void dump_%s (%s x)\n{\n",
entry->object_name, entry->object_name);
fprintf (cfile, "\tfprintf (stdout, \"**************** %s ****************\\n\");\n", entry->object_name);
table = mdb_read_table (entry);
/* get the columns */
mdb_read_columns (table);
/* loop over the columns, dumping the names and types */
for (k = 0; k < table->num_cols; k++)
{
col = g_ptr_array_index (table->columns, k);
fprintf (cfile, "\tfprintf (stdout, \"x.");
for (j = 0; j < strlen (col->name); j++)
{
fprintf (cfile, "%c", tolower (col->name [j]));
}
fprintf (cfile, " = \");\n");
switch (col->col_type)
{
case MDB_INT:
fprintf (typesfile, "\tint\t");
fprintf (cfile, "\tdump_int (x.");
break;
case MDB_LONGINT:
fprintf (typesfile, "\tlong\t");
fprintf (cfile, "\tdump_long (x.");
break;
case MDB_TEXT:
case MDB_MEMO:
fprintf (typesfile, "\tchar *\t");
fprintf (cfile, "\tdump_string (x.");
break;
default:
unsupported = 1;
break;
}
for (j = 0; j < strlen (col->name); j++)
{
fprintf (typesfile, "%c", tolower (col->name [j]));
fprintf (cfile, "%c", tolower (col->name [j]));
}
fprintf (typesfile, ";\n");
fprintf (cfile, ");\n");
}
fprintf (typesfile, "\n} %s ;\n", entry->object_name);
fprintf (typesfile, "\n");
fprintf (cfile, "}\n\n");
mdb_free_tabledef(table);
}
fclose (headerfile);
fclose (typesfile);
fclose (cfile);
mdb_close (mdb);
mdb_exit();
if (unsupported)
fputs("ERROR: unsupported type.\n", stderr);
exit(unsupported);
}
int
main(int argc, char **argv)
{
MdbHandle *mdb;
MdbTableDef *table;
gchar name[256];
gchar *propColName;
void *buf;
int col_num;
int found = 0;
if (argc < 3) {
fprintf(stderr,"Usage: %s <file> <object name> [<prop col>]\n",
argv[0]);
return 1;
}
if (argc < 4)
propColName = "LvProp";
else
propColName = argv[3];
mdb_init();
mdb = mdb_open(argv[1], MDB_NOFLAGS);
if (!mdb) {
mdb_exit();
return 1;
}
table = mdb_read_table_by_name(mdb, "MSysObjects", MDB_ANY);
if (!table) {
mdb_close(mdb);
mdb_exit();
return 1;
}
mdb_read_columns(table);
mdb_rewind_table(table);
mdb_bind_column_by_name(table, "Name", name, NULL);
buf = g_malloc(MDB_BIND_SIZE);
col_num = mdb_bind_column_by_name(table, propColName, buf, NULL);
if (col_num < 1) {
g_free(buf);
mdb_free_tabledef(table);
mdb_close(mdb);
mdb_exit();
printf("Column %s not found in MSysObjects!\n", argv[3]);
return 1;
}
while(mdb_fetch_row(table)) {
if (!strcmp(name, argv[2])) {
found = 1;
break;
}
}
if (found) {
MdbColumn *col = g_ptr_array_index(table->columns, col_num-1);
size_t size;
void *kkd = mdb_ole_read_full(mdb, col, &size);
dump_kkd(mdb, kkd, size);
free(kkd);
}
g_free(buf);
mdb_free_tabledef(table);
mdb_close(mdb);
mdb_exit();
return 0;
}
int main(int argc, char **argv, char **envp)
{
CGI *cgi = NULL;
NEOERR *err;
mdb_conn *conn = NULL;
/* skey, user, pass, return jsoncallback*/
char *s, *u, *p, *r, *jcbk;
/* keeptime(hours) */
int t;
char tm[LEN_TM_GMT];
//sleep(20);
mtc_init("login");
mconfig_parse_file(SITE_CONFIG, &g_cfg);
mutil_wrap_fcgi(argc, argv, envp);
if (mdb_init(&conn, DB_DSN) != MDB_ERR_NONE) {
mtc_err("init db error %s", mdb_get_errmsg(conn));
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
return 1;
}
#ifndef DROP_FCGI
while (FCGI_Accept() >= 0) {
#endif
/*
* cgi init
*/
err = cgi_init(&cgi, NULL);
if (err != STATUS_OK) {
mtc_err("init cgi error");
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
goto opfinish;
}
err = cgi_parse(cgi);
if (err != STATUS_OK) {
mtc_err("parse cgi error");
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_PARSE);
goto opfinish;
}
#if 0
if (mutil_client_attack_cookie(cgi->hdf, "login", 30, 60)) {
mtc_err("client attack");
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_NEEDREST);
goto opfinish;
}
#endif
u = hdf_get_value(cgi->hdf, PRE_COOKIE".samuser", NULL);
s = hdf_get_value(cgi->hdf, PRE_COOKIE".samkey", NULL);
if (s && u) {
if (user_has_login(conn, u, s)) {
hdf_set_copy(cgi->hdf, PRE_OUTPUT".samuser", PRE_COOKIE".samuser");
hdf_set_copy(cgi->hdf, PRE_OUTPUT".samkey", PRE_COOKIE".samkey");
goto done;
}
}
u = hdf_get_value(cgi->hdf, PRE_QUERY".u", NULL);
p = hdf_get_value(cgi->hdf, PRE_QUERY".p", NULL);
if (!u || !p) {
mtc_err("parameter miss %s %s", u, p);
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_NEEDINPUT);
goto opfinish;
}
s = user_login_auth(conn, u, p);
if (!s) {
mtc_err("login error %s %s", u, p);
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_PASSW);
goto opfinish;
}
cgiwrap_write(P3P_HEADER, strlen(P3P_HEADER));
cgi_cookie_set(cgi, "samuser", u, NULL, SITE_DOMAIN, NULL, 1, 0);
cgi_cookie_set(cgi, "samkey", s, NULL, SITE_DOMAIN, NULL, 1, 0);
#if 0
t = hdf_get_int_value(cgi->hdf, PRE_QUERY".t", 0);
mmisc_getdatetime_gmt(tm, sizeof(tm), "%A, %d-%b-%Y %T GMT", 60*60*t);
cgi_cookie_set(cgi, "samkey", s, NULL, SITE_DOMAIN, tm, 1, 0);
#endif
hdf_set_value(cgi->hdf, PRE_OUTPUT".samuser", u);
hdf_set_value(cgi->hdf, PRE_OUTPUT".samkey", s);
free(s);
done:
/*
* TODO set samkey, samuser to app's domain
* DONE this is done by jsonp
*/
hdf_set_value(cgi->hdf, PRE_OUTPUT".success", "1");
opfinish:
if (cgi) {
r = hdf_get_value(cgi->hdf, PRE_QUERY".r", NULL);
if (r) {
cgi_redirect(cgi, r);
} else {
jcbk = hdf_get_value(cgi->hdf, PRE_QUERY".jsoncallback", NULL);
if (jcbk != NULL) {
mjson_execute_hdf(cgi->hdf, jcbk, 0);
} else {
mjson_output_hdf(cgi->hdf, 0);
}
}
#ifdef DEBUG_HDF
hdf_write_file(cgi->hdf, HF_LOG_PATH"hdf.login");
#endif
cgi_destroy(&cgi);
}
#ifndef DROP_FCGI
} /* FCGI_Accept() */
#endif
mdb_destroy(conn);
return 0;
}
int
main (int argc, char **argv)
{
unsigned int j;
MdbHandle *mdb;
MdbTableDef *table;
MdbColumn *col;
/* doesn't handle tables > 256 columns. Can that happen? */
char *bound_values [256];
char delimiter [] = ", ";
char quote_text = 1;
int count = 0;
int started;
if (argc < 3)
{
fprintf (stderr, "Usage: %s <file> <table>\n", argv [0]);
exit (1);
}
mdb_init();
mdb = mdb_open (argv [1], MDB_NOFLAGS);
table = mdb_read_table_by_name (mdb, argv[2], MDB_TABLE);
if (table)
{
mdb_read_columns (table);
mdb_rewind_table (table);
for (j = 0; j < table->num_cols; j++)
{
bound_values [j] = (char *) g_malloc (MDB_BIND_SIZE);
bound_values [j] [0] = '\0';
mdb_bind_column (table, j+1, bound_values[j], NULL);
}
fprintf (stdout, "/******************************************************************/\n");
fprintf (stdout, "/* THIS IS AN AUTOMATICALLY GENERATED FILE. DO NOT EDIT IT!!!!!! */\n");
fprintf (stdout, "/******************************************************************/\n");
fprintf (stdout, "\n");
fprintf (stdout, "#include <stdio.h>\n");
fprintf (stdout, "#include \"types.h\"\n");
fprintf (stdout, "#include \"dump.h\"\n");
fprintf (stdout, "\n");
fprintf (stdout, "const %s %s_array [] = {\n", argv [2], argv [2]);
count = 0;
started = 0;
while (mdb_fetch_row (table))
{
if (started != 0)
{
fprintf (stdout, ",\n");
}
started = 1;
fprintf (stdout, "{\t\t\t\t/* %6d */\n\t", count);
for (j = 0; j < table->num_cols; j++)
{
fprintf (stdout, "\t");
col = g_ptr_array_index (table->columns, j);
if (quote_text &&
(col->col_type == MDB_TEXT ||
col->col_type == MDB_MEMO))
{
fprintf (stdout, "\"%s\"", bound_values [j]);
}
else
{
fprintf (stdout, "%s", bound_values [j]);
}
if (j != table->num_cols - 1)
{
fprintf (stdout, "%s\n", delimiter);
}
else
{
fprintf (stdout, "\n");
}
}
fprintf (stdout, "}");
count++;
}
fprintf (stdout, "\n};\n\n");
for (j = 0; j < table->num_cols; j++)
{
g_free (bound_values [j]);
}
mdb_free_tabledef(table);
}
mdb_close (mdb);
mdb_exit();
fprintf (stdout, "const int %s_array_length = %d;\n",
argv [2],
count);
exit(0);
}
int main(int argc, char **argv, char **envp)
{
CGI *cgi = NULL;
NEOERR *err;
mdb_conn *conn = NULL;
/* skey, user, pass, return jsoncallback*/
char *s, *u, *r, *jcbk;
//sleep(20);
mtc_init("logout");
mconfig_parse_file(SITE_CONFIG, &g_cfg);
mutil_wrap_fcgi(argc, argv, envp);
if (mdb_init(&conn, DB_DSN) != MDB_ERR_NONE) {
mtc_err("init db error %s", mdb_get_errmsg(conn));
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
return 1;
}
#ifndef DROP_FCGI
while (FCGI_Accept() >= 0) {
#endif
/*
* cgi init
*/
err = cgi_init(&cgi, NULL);
if (err != STATUS_OK) {
mtc_err("init cgi error");
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
goto opfinish;
}
err = cgi_parse(cgi);
if (err != STATUS_OK) {
mtc_err("parse cgi error");
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_PARSE);
goto opfinish;
}
u = hdf_get_value(cgi->hdf, PRE_COOKIE".samuser", NULL);
s = hdf_get_value(cgi->hdf, PRE_COOKIE".samkey", NULL);
if (s && u) {
if (user_has_login(conn, u, s)) {
user_logout(conn, u);
cgi_cookie_clear(cgi, "samuser", SITE_DOMAIN, NULL);
cgi_cookie_clear(cgi, "samkey", SITE_DOMAIN, NULL);
hdf_set_value(cgi->hdf, PRE_OUTPUT".success", "1");
goto opfinish;
}
}
hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_NOTLOGIN);
opfinish:
if (cgi) {
r = hdf_get_value(cgi->hdf, PRE_QUERY".r", NULL);
if (r) {
cgi_redirect(cgi, r);
} else {
jcbk = hdf_get_value(cgi->hdf, PRE_QUERY".jsoncallback", NULL);
if (jcbk != NULL) {
mjson_execute_hdf(cgi->hdf, jcbk, 0);
} else {
mjson_output_hdf(cgi->hdf, 0);
}
}
#ifdef DEBUG_HDF
hdf_write_file(cgi->hdf, HF_LOG_PATH"hdf.logout");
#endif
cgi_destroy(&cgi);
}
#ifndef DROP_FCGI
} /* FCGI_Accept() */
#endif
mdb_destroy(conn);
return 0;
}
static ngx_int_t
ngx_http_tcache_mdb_init(ngx_http_tcache_t *cache)
{
size_t len;
u_char *name, *path;
ngx_mdb_t *mdb;
mdb_param_t params;
mdb = ngx_pcalloc(cache->pool, sizeof(ngx_mdb_t));
if (mdb == NULL) {
return NGX_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cache->log, 0, "tcache mdb init");
mdb->log = (char *) cache->log->file->name.data;
mdb_log_file(mdb->log);
mdb_log_level("error");
ngx_memzero(¶ms, sizeof(mdb_param_t));
len = sizeof("libmdb_") - 1 + cache->name.len;
name = ngx_pcalloc(cache->pool, len + 1);
if (name == NULL) {
return NGX_ERROR;
}
ngx_snprintf(name, len, "%s%V", (u_char *) "libmdb_", &cache->name);
len += sizeof("/dev/shm/") - 1;
path = ngx_pcalloc(cache->pool, len + 1);
if (path == NULL) {
return NGX_ERROR;
}
ngx_snprintf(path, len, "/dev/shm/%s", name);
mdb->path = (char *)path;
#if NGX_LINUX && 0
ngx_fd_t fd;
struct flock fl;
fd = open((char *)path, O_RDWR);
if (fd > 0) {
fl.l_start = 0;
fl.l_len = 0;
fl.l_pid = 0;
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;
/* record lock can't inherit after fork, sucks */
if (fcntl(fd, F_SETLK, &fl) == -1) {
ngx_log_error(NGX_LOG_EMERG, cache->log, 0,
"tcache error: the shared memory \"%s\" is using",
name);
return NGX_ERROR;
}
}
#endif
ngx_delete_file(mdb->path);
params.mdb_type = "mdb_shm";
params.mdb_path = (char *) name;
params.size = cache->size;
mdb->db = mdb_init(¶ms);
mdb->area = 0;
mdb->quota = cache->size >> 1;
mdb_set_quota(mdb->db, mdb->area, mdb->quota);
cache->mdb = mdb;
return NGX_OK;
}
main (int argc, char **argv)
{
int i, j, k;
MdbHandle *mdb;
MdbCatalogEntry *entry;
MdbTableDef *table;
MdbColumn *col;
char *the_relation;
char *tabname = NULL;
int opt;
if (argc < 2) {
fprintf (stderr, "Usage: %s <file> [<backend>]\n",argv[0]);
exit (1);
}
while ((opt=getopt(argc, argv, "T:"))!=-1) {
switch (opt) {
case 'T':
tabname = (char *) malloc(strlen(optarg)+1);
strcpy(tabname, optarg);
break;
}
}
mdb_init();
/* open the database */
mdb = mdb_open (argv[optind]);
if (argc - optind >2) {
if (!mdb_set_default_backend(mdb, argv[optind + 1])) {
fprintf(stderr,"Invalid backend type\n");
mdb_exit();
exit(1);
}
}
/* read the catalog */
mdb_read_catalog (mdb, MDB_TABLE);
/* loop over each entry in the catalog */
for (i=0; i < mdb->num_catalog; i++)
{
entry = g_ptr_array_index (mdb->catalog, i);
/* if it's a table */
if (entry->object_type == MDB_TABLE)
{
/* skip the MSys tables */
if ((tabname && !strcmp(entry->object_name,tabname)) ||
(!tabname && strncmp (entry->object_name, "MSys", 4)))
{
/* make sure it's a table (may be redundant) */
if (!strcmp (mdb_get_objtype_string (entry->object_type), "Table"))
{
/* drop the table if it exists */
fprintf (stdout, "DROP TABLE %s;\n", entry->object_name);
/* create the table */
fprintf (stdout, "CREATE TABLE %s\n", entry->object_name);
fprintf (stdout, " (\n");
table = mdb_read_table (entry);
/* get the columns */
mdb_read_columns (table);
/* loop over the columns, dumping the names and types */
for (k = 0; k < table->num_cols; k++)
{
col = g_ptr_array_index (table->columns, k);
fprintf (stdout, "\t%s\t\t\t%s", col->name,
mdb_get_coltype_string (mdb->default_backend, col->col_type));
if (col->col_size != 0)
fprintf (stdout, " (%d)", col->col_size);
if (k < table->num_cols - 1)
fprintf (stdout, ", \n");
else
fprintf (stdout, "\n");
}
fprintf (stdout, "\n);\n");
fprintf (stdout, "-- CREATE ANY INDEXES ...\n");
fprintf (stdout, "\n");
}
}
}
}
fprintf (stdout, "\n\n");
fprintf (stdout, "-- CREATE ANY Relationships ...\n");
fprintf (stdout, "\n");
the_relation=mdb_get_relationships(mdb);
while (the_relation[0] != '\0') {
fprintf(stdout,"%s\n",the_relation);
the_relation=mdb_get_relationships(mdb);
}
mdb_free_handle (mdb);
mdb_exit();
exit(0);
}
