Example #1
1
int main (int argc, char **argv) {
  sqlite3 *db;          // Definimos un puntero a la base de datos
  char *errMsg = 0;     // Variable para el mensaje de error
  int rc;               // Variable para el retorno de la sentencia
  sqlite3_stmt *result; // Puntero a la respuesta de la consulta

  // Abro la conexión con la base de datos
  rc = sqlite3_open("BDPrueba.sqlite", &db);
  // Compruebo que no hay error
  if (rc != SQLITE_OK) {
    fprintf(stderr, "No se puede acceder a la base de datos: %s.\n", sqlite3_errmsg(db));
    sqlite3_close(db);
    return(1);
  }

  // Borro la tabla si no existe
  rc = sqlite3_exec(db, "DROP TABLE IF EXISTS Empresa", NULL, NULL, &errMsg);
  if (rc != SQLITE_OK) {
    fprintf(stderr, "Error al borrar la tabla: %s.\n", errMsg);
    sqlite3_free(errMsg);
    sqlite3_close(db);
    return(2);
  }
  // Creo la tabla Empresa
  rc = sqlite3_exec(db, "CREATE TABLE Empresa (IdEmpresa INTEGER PRIMARY KEY, Nombre CHAR[250])", NULL, NULL, &errMsg);
  if (rc != SQLITE_OK) {
    fprintf(stderr, "Error al crear la tabla: %s.\n", errMsg);
    sqlite3_free(errMsg);
    sqlite3_close(db);
    return(2);
  }
  // Inserto un par de registros
  rc = sqlite3_exec(db, "INSERT INTO Empresa VALUES( 1, 'Empresa A')", NULL, NULL, &errMsg);
  if (rc != SQLITE_OK) {
    fprintf(stderr, "Error al crear el primer registro: %s.\n", errMsg);
    sqlite3_free(errMsg);
    sqlite3_close(db);
    return(2);
  }
  rc = sqlite3_exec(db, "INSERT INTO Empresa VALUES( 2, 'Empresa B')", NULL, NULL, &errMsg);
  if (rc != SQLITE_OK) {
    fprintf(stderr, "Error al crear el segundo registro: %s.\n", errMsg);
    sqlite3_free(errMsg);
    sqlite3_close(db);
    return(2);
  }

  // Consulta a realizar sobre la tabla.
  // En este caso quiero los campos idEmpresa y Nombre de la tabla Empresa
  rc = sqlite3_prepare(db, "SELECT idEmpresa,Nombre FROM Empresa", -1, &result, NULL);
  // Compruebo que no hay error
  if (rc != SQLITE_OK) {
    fprintf(stderr, "Error en la consulta: %s.\n", sqlite3_errmsg(db));
    sqlite3_close(db);
    return(3);
  }

  // Bucle de presentación en pantalla del resultado de la consulta
  while ( sqlite3_step(result) == SQLITE_ROW) {
    fprintf(stderr, "El Id y nombre de la empresa son:  %i - %s.\n", sqlite3_column_int(result, 0)
                                                                   , sqlite3_column_text(result, 1));
  }

  // Cierro la conexión
  sqlite3_close(db);

  return 0;
}
int
main(int argc, char **argv)
{
	int addrtype = 0;
	int privtype = 128;
	int regex = 0;
	int caseinsensitive = 0;
	int opt;
	char pwbuf[128];
	int platformidx = -1, deviceidx = -1;
	int prompt_password = 0;
	char *seedfile = NULL;
	char **patterns, *pend;
	int verbose = 1;
	int npatterns = 0;
	int nthreads = 0;
	int worksize = 0;
	int nrows = 0, ncols = 0;
	int invsize = 0;
	int remove_on_match = 1;
	int only_one = 0;
	int verify_mode = 0;
	int safe_mode = 0;
	vg_context_t *vcp = NULL;
	vg_ocl_context_t *vocp = NULL;
	EC_POINT *pubkey_base = NULL;
	const char *result_file = NULL;
	const char *key_password = NULL;
	char *devstrs[MAX_DEVS];
	int ndevstrs = 0;
	int opened = 0;

	FILE *pattfp[MAX_FILE], *fp;
	int pattfpi[MAX_FILE];
	int npattfp = 0;
	int pattstdin = 0;

	sqlite3 *db;

	int i;

	while ((opt = getopt(argc, argv,
			     "vqik1NTX:eE:p:P:d:w:t:g:b:VSh?f:o:s:D:H")) != -1) {
		switch (opt) {
		case 'v':
			verbose = 2;
			break;
		case 'q':
			verbose = 0;
			break;
		case 'i':
			caseinsensitive = 1;
			break;
		case 'k':
			remove_on_match = 0;
			break;
		case '1':
			only_one = 1;
			break;
		case 'N':
			addrtype = 52;
			privtype = 180;
			break;
		case 'T':
			addrtype = 111;
			privtype = 239;
			break;
		case 'X':
			addrtype = atoi(optarg);
			privtype = 128 + addrtype;
			break;
		case 'e':
			prompt_password = 1;
			break;
		case 'E':
			key_password = optarg;
			break;
		case 'p':
			platformidx = atoi(optarg);
			break;
		case 'd':
			deviceidx = atoi(optarg);
			break;
		case 'w':
			worksize = atoi(optarg);
			if (worksize == 0) {
				fprintf(stderr,
					"Invalid work size '%s'\n", optarg);
				return 1;
			}
			break;
		case 't':
			nthreads = atoi(optarg);
			if (nthreads == 0) {
				fprintf(stderr,
					"Invalid thread count '%s'\n", optarg);
				return 1;
			}
			break;
		case 'g':
			nrows = 0;
			ncols = strtol(optarg, &pend, 0);
			if (pend && *pend == 'x') {
				nrows = strtol(pend+1, NULL, 0);
			}
			if (!nrows || !ncols) {
				fprintf(stderr,
					"Invalid grid size '%s'\n", optarg);
				return 1;
			}
			break;
		case 'b':
			invsize = atoi(optarg);
			if (!invsize) {
				fprintf(stderr,
					"Invalid modular inverse size '%s'\n",
					optarg);
				return 1;
			}
			if (invsize & (invsize - 1)) {
				fprintf(stderr,
					"Modular inverse size must be "
					"a power of 2\n");
				return 1;
			}
			break;
		case 'V':
			verify_mode = 1;
			break;
		case 'S':
			safe_mode = 1;
			break;
		case 'D':
			if (ndevstrs >= MAX_DEVS) {
				fprintf(stderr,
					"Too many OpenCL devices (limit %d)\n",
					MAX_DEVS);
				return 1;
			}
			devstrs[ndevstrs++] = optarg;
			break;
		case 'P': {
			if (pubkey_base != NULL) {
				fprintf(stderr,
					"Multiple base pubkeys specified\n");
				return 1;
			}
			EC_KEY *pkey = vg_exec_context_new_key();
			pubkey_base = EC_POINT_hex2point(
				EC_KEY_get0_group(pkey),
				optarg, NULL, NULL);
			EC_KEY_free(pkey);
			if (pubkey_base == NULL) {
				fprintf(stderr,
					"Invalid base pubkey\n");
				return 1;
			}
			break;
		}
		case 'f':
			if (npattfp >= MAX_FILE) {
				fprintf(stderr,
					"Too many input files specified\n");
				return 1;
			}
			if (!strcmp(optarg, "-")) {
				if (pattstdin) {
					fprintf(stderr, "ERROR: stdin "
						"specified multiple times\n");
					return 1;
				}
				fp = stdin;
			} else {
				fp = fopen(optarg, "r");
				if (!fp) {
					fprintf(stderr,
						"Could not open %s: %s\n",
						optarg, strerror(errno));
					return 1;
				}
			}
			pattfp[npattfp] = fp;
			pattfpi[npattfp] = caseinsensitive;
			npattfp++;
			break;
		case 'o':
			if (result_file) {
				fprintf(stderr,
					"Multiple output files specified\n");
				return 1;
			}
			result_file = optarg;
			break;
		case 's':
			if (seedfile != NULL) {
				fprintf(stderr,
					"Multiple RNG seeds specified\n");
				return 1;
			}
			seedfile = optarg;
			break;
		case 'H':
			fprintf(stderr,
				"Saving to database\n");
			int rc;
			char* zErrMsg;
			char* sql;

			/* Open database */
			rc = sqlite3_open("btc_dataBase.db", &db);
			if (rc) {
				fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
				sqlite3_close(db);
				exit(EXIT_FAILURE);
			} else {
				fprintf(stdout, "Opened database successfully\n");
			}

			/* Create Table */
			sql = "CREATE TABLE BITCOIN("					\
				  "ADDRESS CHAR(50) PRIMARY KEY NOT NULL,"  \
				  "PRIVKEY CHAR(70)             NOT NULL,"  \
				  "PATTERN CHAR(20)             NOT NULL);";

			/* Execute Create Table*/
			rc = sqlite3_exec(db, sql, callback, NULL, &zErrMsg);
			if (rc != SQLITE_OK) {
				fprintf(stderr, "CREATE TABLE SQL error: %s\n", zErrMsg);
				sqlite3_free(zErrMsg);
			} else {
				fprintf(stdout, "CREATE TABLE successfully\n");
			}
			sqlite3_close(db);

			break;
		default:
			usage(argv[0]);
			return 1;
		}
	}

#if OPENSSL_VERSION_NUMBER < 0x10000000L
	/* Complain about older versions of OpenSSL */
	if (verbose > 0) {
		fprintf(stderr,
			"WARNING: Built with " OPENSSL_VERSION_TEXT "\n"
			"WARNING: Use OpenSSL 1.0.0d+ for best performance\n");
	}
#endif

	if (caseinsensitive && regex)
		fprintf(stderr,
			"WARNING: case insensitive mode incompatible with "
			"regular expressions\n");

	if (seedfile) {
		opt = -1;
#if !defined(_WIN32)
		{	struct stat st;
			if (!stat(seedfile, &st) &&
			    (st.st_mode & (S_IFBLK|S_IFCHR))) {
				opt = 32;
		} }
#endif
		opt = RAND_load_file(seedfile, opt);
		if (!opt) {
			fprintf(stderr, "Could not load RNG seed %s\n", optarg);
			return 1;
		}
		if (verbose > 0) {
			fprintf(stderr,
				"Read %d bytes from RNG seed file\n", opt);
		}
	}

	if (regex) {
		vcp = vg_regex_context_new(addrtype, privtype);

	} else {
		vcp = vg_prefix_context_new(addrtype, privtype,
					    caseinsensitive);
	}

	vcp->vc_verbose = verbose;
	vcp->vc_result_file = result_file;
	vcp->vc_remove_on_match = remove_on_match;
	vcp->vc_only_one = only_one;
	vcp->vc_pubkeytype = addrtype;
	vcp->vc_pubkey_base = pubkey_base;

	vcp->vc_output_match = vg_output_match_console;
	vcp->vc_output_timing = vg_output_timing_console;

	if (!npattfp) {
		if (optind >= argc) {
			usage(argv[0]);
			return 1;
		}
		patterns = &argv[optind];
		npatterns = argc - optind;

		if (!vg_context_add_patterns(vcp,
					     (const char ** const) patterns,
					     npatterns))
		return 1;
	}

	for (i = 0; i < npattfp; i++) {
		fp = pattfp[i];
		if (!vg_read_file(fp, &patterns, &npatterns)) {
			fprintf(stderr, "Failed to load pattern file\n");
			return 1;
		}
		if (fp != stdin)
			fclose(fp);

		if (!regex)
			vg_prefix_context_set_case_insensitive(vcp, pattfpi[i]);

		if (!vg_context_add_patterns(vcp,
					     (const char ** const) patterns,
					     npatterns))
		return 1;
	}

	if (!vcp->vc_npatterns) {
		fprintf(stderr, "No patterns to search\n");
		return 1;
	}

	if (prompt_password) {
		if (!vg_read_password(pwbuf, sizeof(pwbuf)))
			return 1;
		key_password = pwbuf;
	}
	vcp->vc_key_protect_pass = key_password;
	if (key_password) {
		if (!vg_check_password_complexity(key_password, verbose))
			fprintf(stderr,
				"WARNING: Protecting private keys with "
				"weak password\n");
	}

	if ((verbose > 0) && regex && (vcp->vc_npatterns > 1))
		fprintf(stderr,
			"Regular expressions: %ld\n", vcp->vc_npatterns);

	if (ndevstrs) {
		for (opt = 0; opt < ndevstrs; opt++) {
			vocp = vg_ocl_context_new_from_devstr(vcp, devstrs[opt],
							      safe_mode,
							      verify_mode);
			if (!vocp) {
				fprintf(stderr,
				"Could not open device '%s', ignoring\n",
					devstrs[opt]);
			} else {
				opened++;
			}
		}
	} else {
		vocp = vg_ocl_context_new(vcp, platformidx, deviceidx,
					  safe_mode, verify_mode,
					  worksize, nthreads,
					  nrows, ncols, invsize);
		if (vocp)
			opened++;
	}

	if (!opened) {
		vg_ocl_enumerate_devices();
		return 1;
	}

	opt = vg_context_start_threads(vcp);
	if (opt)
		return 1;

	vg_context_wait_for_completion(vcp);
	vg_ocl_context_free(vocp);
	return 0;
}
Example #3
0
static int try_to_open_db(const char *filename, struct memblock *mem, struct dive_table *table)
{
	sqlite3 *handle;
	char dm4_test[] = "select count(*) from sqlite_master where type='table' and name='Dive' and sql like '%ProfileBlob%'";
	char dm5_test[] = "select count(*) from sqlite_master where type='table' and name='Dive' and sql like '%SampleBlob%'";
	char shearwater_test[] = "select count(*) from sqlite_master where type='table' and name='system' and sql like '%dbVersion%'";
	char cobalt_test[] = "select count(*) from sqlite_master where type='table' and name='TrackPoints' and sql like '%DepthPressure%'";
	char divinglog_test[] = "select count(*) from sqlite_master where type='table' and name='DBInfo' and sql like '%PrgName%'";
	int retval;

	retval = sqlite3_open(filename, &handle);

	if (retval) {
		fprintf(stderr, "Database connection failed '%s'.\n", filename);
		return 1;
	}

	/* Testing if DB schema resembles Suunto DM5 database format */
	retval = sqlite3_exec(handle, dm5_test, &db_test_func, 0, NULL);
	if (!retval) {
		retval = parse_dm5_buffer(handle, filename, mem->buffer, mem->size, table);
		sqlite3_close(handle);
		return retval;
	}

	/* Testing if DB schema resembles Suunto DM4 database format */
	retval = sqlite3_exec(handle, dm4_test, &db_test_func, 0, NULL);
	if (!retval) {
		retval = parse_dm4_buffer(handle, filename, mem->buffer, mem->size, table);
		sqlite3_close(handle);
		return retval;
	}

	/* Testing if DB schema resembles Shearwater database format */
	retval = sqlite3_exec(handle, shearwater_test, &db_test_func, 0, NULL);
	if (!retval) {
		retval = parse_shearwater_buffer(handle, filename, mem->buffer, mem->size, table);
		sqlite3_close(handle);
		return retval;
	}

	/* Testing if DB schema resembles Atomic Cobalt database format */
	retval = sqlite3_exec(handle, cobalt_test, &db_test_func, 0, NULL);
	if (!retval) {
		retval = parse_cobalt_buffer(handle, filename, mem->buffer, mem->size, table);
		sqlite3_close(handle);
		return retval;
	}

	/* Testing if DB schema resembles Divinglog database format */
	retval = sqlite3_exec(handle, divinglog_test, &db_test_func, 0, NULL);
	if (!retval) {
		retval = parse_divinglog_buffer(handle, filename, mem->buffer, mem->size, table);
		sqlite3_close(handle);
		return retval;
	}

	sqlite3_close(handle);

	return retval;
}
Example #4
0
// opens a new sqlite database
DBInterface::DBInterface(std::string db_path)
{
    sqlite3_open(db_path.c_str(), &database);
}
Example #5
0
gboolean gc_db_init(gboolean disable_database_)
{

#ifdef USE_SQLITE
  disable_database = disable_database_;
  SUPPORT_OR_RETURN(FALSE);
  gboolean creation = FALSE;
  char *zErrMsg;
  char **result;
  int rc;
  int nrow;
  int ncolumn;

  GcomprisProperties	*properties = gc_prop_get();

  if (!g_file_test(properties->database, G_FILE_TEST_EXISTS))
    creation = TRUE;

  rc = sqlite3_open(properties->database, &gcompris_db);
  if( rc ){
    g_message("Can't open database %s : %s\n", properties->database,
	      sqlite3_errmsg(gcompris_db));
    sqlite3_close(gcompris_db);
    disable_database = TRUE;
    return FALSE;
  }

  g_message("Database %s opened", properties->database);

  if (creation){
    _create_db();
  } else {
    if ( ! _check_db_integrity() ||
	 _gc_boards_count() == 0 )
      {
	// We failed to load the database, let's
	// backup it and re create it.
	sqlite3_close(gcompris_db);
	gchar *backup = g_strdup_printf("%s.broken", properties->database);
	if ( g_rename(properties->database, backup) < 0 )
	  {
	    // Obviously, we cannot write the backup file either
	    g_message("Failed to write the backup database %s", backup);
	    disable_database = TRUE;
	    return FALSE;
	  }
	else
	  g_message("Database is broken, it is copyed in %s", backup);
	g_free(backup);

	rc = sqlite3_open(properties->database, &gcompris_db);
	if( rc ){
	  g_message("Can't open database %s : %s\n", properties->database,
		    sqlite3_errmsg(gcompris_db));
	  sqlite3_close(gcompris_db);
	  disable_database = TRUE;
	  return FALSE;
	}
	_create_db();

	if ( ! _check_db_integrity() )
	  {
	    disable_database = TRUE;
	    return FALSE;
	  }
      }

    g_message("Database Integrity ok");

    rc = sqlite3_get_table(gcompris_db,
			   CHECK_VERSION,
			   &result,
			   &nrow,
			   &ncolumn,
			   &zErrMsg
			   );
    if( rc!=SQLITE_OK ){
      g_error("SQL error: %s\n", zErrMsg);
    }

    if (strcmp(result[1],VERSION)!=0)
      g_message("Running GCompris is %s, but database version is %s", VERSION, result[1]);
    sqlite3_free_table(result);

    /* Schema upgrade */
    rc = sqlite3_get_table(gcompris_db,
			   PRAGMA_SCHEMA_VERSION,
			   &result,
			   &nrow,
			   &ncolumn,
			   &zErrMsg
			   );
    if( rc!=SQLITE_OK ){
      g_error("SQL error: %s\n", zErrMsg);
    }

    int version = atoi(result[1]);
    sqlite3_free_table(result);
    if(version <= 16)
      {
	g_message("Upgrading from <16 schema version\n");
	rc = sqlite3_exec(gcompris_db,CREATE_TABLE_LOGS, NULL,  0, &zErrMsg);
	if( rc!=SQLITE_OK ) {
	  g_error("SQL error: %s\n", zErrMsg);
	}
      }
    if ( _get_user_version() == 0)
      {
	g_message("Upgrading schema based on user version = 0\n");
	rc = sqlite3_exec(gcompris_db,"DROP TABLE boards;", NULL,  0, &zErrMsg);
	if( rc!=SQLITE_OK ) {
	  g_error("SQL error: %s\n", zErrMsg);
	}
	rc = sqlite3_exec(gcompris_db,CREATE_TABLE_BOARDS, NULL,  0, &zErrMsg);
	if( rc!=SQLITE_OK ) {
	  g_error("SQL error: %s\n", zErrMsg);
	}
	// We just dropped the boards table, force a reread
	properties->reread_menu = TRUE;
	_set_user_version(1);
      }
  }

  return TRUE;
#else
  return FALSE;
#endif
}
Example #6
0
int main(int argc, char **argv){
  const char *zDb;
  int rc = 0;
  char *zErr = 0;
  int i;
  int iVerbose = 1;               /* -verbose option */

  sqlite3 *db = 0;
  sqlite3expert *p = 0;

  if( argc<2 ) usage(argv);
  zDb = argv[argc-1];
  if( zDb[0]=='-' ) usage(argv);
  rc = sqlite3_open(zDb, &db);
  if( rc!=SQLITE_OK ){
    fprintf(stderr, "Cannot open db file: %s - %s\n", zDb, sqlite3_errmsg(db));
    exit(-2);
  }

  p = sqlite3_expert_new(db, &zErr);
  if( p==0 ){
    fprintf(stderr, "Cannot run analysis: %s\n", zErr);
    rc = 1;
  }else{
    for(i=1; i<(argc-1); i++){
      char *zArg = argv[i];
      int nArg;
      if( zArg[0]=='-' && zArg[1]=='-' && zArg[2]!=0 ) zArg++;
      nArg = (int)strlen(zArg);
      if( nArg>=2 && 0==sqlite3_strnicmp(zArg, "-file", nArg) ){
        if( ++i==(argc-1) ) option_requires_argument("-file");
        rc = readSqlFromFile(p, argv[i], &zErr);
      }

      else if( nArg>=3 && 0==sqlite3_strnicmp(zArg, "-sql", nArg) ){
        if( ++i==(argc-1) ) option_requires_argument("-sql");
        rc = sqlite3_expert_sql(p, argv[i], &zErr);
      }

      else if( nArg>=3 && 0==sqlite3_strnicmp(zArg, "-sample", nArg) ){
        int iSample;
        if( ++i==(argc-1) ) option_requires_argument("-sample");
        iSample = option_integer_arg(argv[i]);
        sqlite3_expert_config(p, EXPERT_CONFIG_SAMPLE, iSample);
      }

      else if( nArg>=2 && 0==sqlite3_strnicmp(zArg, "-verbose", nArg) ){
        if( ++i==(argc-1) ) option_requires_argument("-verbose");
        iVerbose = option_integer_arg(argv[i]);
      }

      else{
        usage(argv);
      }
    }
  }

  if( rc==SQLITE_OK ){
    rc = sqlite3_expert_analyze(p, &zErr);
  }

  if( rc==SQLITE_OK ){
    int nQuery = sqlite3_expert_count(p);
    if( iVerbose>0 ){
      const char *zCand = sqlite3_expert_report(p,0,EXPERT_REPORT_CANDIDATES);
      fprintf(stdout, "-- Candidates -------------------------------\n");
      fprintf(stdout, "%s\n", zCand);
    }
    for(i=0; i<nQuery; i++){
      const char *zSql = sqlite3_expert_report(p, i, EXPERT_REPORT_SQL);
      const char *zIdx = sqlite3_expert_report(p, i, EXPERT_REPORT_INDEXES);
      const char *zEQP = sqlite3_expert_report(p, i, EXPERT_REPORT_PLAN);
      if( zIdx==0 ) zIdx = "(no new indexes)\n";
      if( iVerbose>0 ){
        fprintf(stdout, "-- Query %d ----------------------------------\n",i+1);
        fprintf(stdout, "%s\n\n", zSql);
      }
      fprintf(stdout, "%s\n%s\n", zIdx, zEQP);
    }
  }else{
    fprintf(stderr, "Error: %s\n", zErr ? zErr : "?");
  }

  sqlite3_expert_destroy(p);
  sqlite3_free(zErr);
  return rc;
}
Example #7
0
int main(int argc, char **argv) {
    sqlite3_int64 iBegin;        /* Start time of this program */
    int quietFlag = 0;           /* True if --quiet or -q */
    int verboseFlag = 0;         /* True if --verbose or -v */
    char *zInsSql = 0;           /* SQL statement for --load-db or --load-sql */
    int iFirstInsArg = 0;        /* First argv[] to use for --load-db or --load-sql */
    sqlite3 *db = 0;             /* The open database connection */
    sqlite3_stmt *pStmt;         /* A prepared statement */
    int rc;                      /* Result code from SQLite interface calls */
    Blob *pSql;                  /* For looping over SQL scripts */
    Blob *pDb;                   /* For looping over template databases */
    int i;                       /* Loop index for the argv[] loop */
    int onlySqlid = -1;          /* --sqlid */
    int onlyDbid = -1;           /* --dbid */
    int nativeFlag = 0;          /* --native-vfs */
    int rebuildFlag = 0;         /* --rebuild */
    int vdbeLimitFlag = 0;       /* --limit-vdbe */
    int timeoutTest = 0;         /* undocumented --timeout-test flag */
    int runFlags = 0;            /* Flags sent to runSql() */
    char *zMsg = 0;              /* Add this message */
    int nSrcDb = 0;              /* Number of source databases */
    char **azSrcDb = 0;          /* Array of source database names */
    int iSrcDb;                  /* Loop over all source databases */
    int nTest = 0;               /* Total number of tests performed */
    char *zDbName = "";          /* Appreviated name of a source database */
    const char *zFailCode = 0;   /* Value of the TEST_FAILURE environment variable */
    int cellSzCkFlag = 0;        /* --cell-size-check */
    int sqlFuzz = 0;             /* True for SQL fuzz testing. False for DB fuzz */
    int iTimeout = 120;          /* Default 120-second timeout */
    int nMem = 0;                /* Memory limit */
    char *zExpDb = 0;            /* Write Databases to files in this directory */
    char *zExpSql = 0;           /* Write SQL to files in this directory */
    void *pHeap = 0;             /* Heap for use by SQLite */

    iBegin = timeOfDay();
#ifdef __unix__
    signal(SIGALRM, timeoutHandler);
#endif
    g.zArgv0 = argv[0];
    zFailCode = getenv("TEST_FAILURE");
    for(i=1; i<argc; i++) {
        const char *z = argv[i];
        if( z[0]=='-' ) {
            z++;
            if( z[0]=='-' ) z++;
            if( strcmp(z,"cell-size-check")==0 ) {
                cellSzCkFlag = 1;
            } else if( strcmp(z,"dbid")==0 ) {
                if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
                onlyDbid = integerValue(argv[++i]);
            } else if( strcmp(z,"export-db")==0 ) {
                if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
                zExpDb = argv[++i];
            } else if( strcmp(z,"export-sql")==0 ) {
                if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
                zExpSql = argv[++i];
            } else if( strcmp(z,"help")==0 ) {
                showHelp();
                return 0;
            } else if( strcmp(z,"limit-mem")==0 ) {
#if !defined(SQLITE_ENABLE_MEMSYS3) && !defined(SQLITE_ENABLE_MEMSYS5)
                fatalError("the %s option requires -DSQLITE_ENABLE_MEMSYS5 or _MEMSYS3",
                           argv[i]);
#else
                if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
                nMem = integerValue(argv[++i]);
#endif
            } else if( strcmp(z,"limit-vdbe")==0 ) {
                vdbeLimitFlag = 1;
            } else if( strcmp(z,"load-sql")==0 ) {
                zInsSql = "INSERT INTO xsql(sqltext) VALUES(CAST(readfile(?1) AS text))";
                iFirstInsArg = i+1;
                break;
            } else if( strcmp(z,"load-db")==0 ) {
                zInsSql = "INSERT INTO db(dbcontent) VALUES(readfile(?1))";
                iFirstInsArg = i+1;
                break;
            } else if( strcmp(z,"m")==0 ) {
                if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
                zMsg = argv[++i];
            } else if( strcmp(z,"native-vfs")==0 ) {
                nativeFlag = 1;
            } else if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ) {
                quietFlag = 1;
                verboseFlag = 0;
            } else if( strcmp(z,"rebuild")==0 ) {
                rebuildFlag = 1;
            } else if( strcmp(z,"result-trace")==0 ) {
                runFlags |= SQL_OUTPUT;
            } else if( strcmp(z,"sqlid")==0 ) {
                if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
                onlySqlid = integerValue(argv[++i]);
            } else if( strcmp(z,"timeout")==0 ) {
                if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
                iTimeout = integerValue(argv[++i]);
            } else if( strcmp(z,"timeout-test")==0 ) {
                timeoutTest = 1;
#ifndef __unix__
                fatalError("timeout is not available on non-unix systems");
#endif
            } else if( strcmp(z,"verbose")==0 || strcmp(z,"v")==0 ) {
                quietFlag = 0;
                verboseFlag++;
                if( verboseFlag>1 ) runFlags |= SQL_TRACE;
            } else
            {
                fatalError("unknown option: %s", argv[i]);
            }
        } else {
            nSrcDb++;
            azSrcDb = safe_realloc(azSrcDb, nSrcDb*sizeof(azSrcDb[0]));
            azSrcDb[nSrcDb-1] = argv[i];
        }
    }
    if( nSrcDb==0 ) fatalError("no source database specified");
    if( nSrcDb>1 ) {
        if( zMsg ) {
            fatalError("cannot change the description of more than one database");
        }
        if( zInsSql ) {
            fatalError("cannot import into more than one database");
        }
    }

    /* Process each source database separately */
    for(iSrcDb=0; iSrcDb<nSrcDb; iSrcDb++) {
        rc = sqlite3_open(azSrcDb[iSrcDb], &db);
        if( rc ) {
            fatalError("cannot open source database %s - %s",
                       azSrcDb[iSrcDb], sqlite3_errmsg(db));
        }
        rc = sqlite3_exec(db,
                          "CREATE TABLE IF NOT EXISTS db(\n"
                          "  dbid INTEGER PRIMARY KEY, -- database id\n"
                          "  dbcontent BLOB            -- database disk file image\n"
                          ");\n"
                          "CREATE TABLE IF NOT EXISTS xsql(\n"
                          "  sqlid INTEGER PRIMARY KEY,   -- SQL script id\n"
                          "  sqltext TEXT                 -- Text of SQL statements to run\n"
                          ");"
                          "CREATE TABLE IF NOT EXISTS readme(\n"
                          "  msg TEXT -- Human-readable description of this file\n"
                          ");", 0, 0, 0);
        if( rc ) fatalError("cannot create schema: %s", sqlite3_errmsg(db));
        if( zMsg ) {
            char *zSql;
            zSql = sqlite3_mprintf(
                       "DELETE FROM readme; INSERT INTO readme(msg) VALUES(%Q)", zMsg);
            rc = sqlite3_exec(db, zSql, 0, 0, 0);
            sqlite3_free(zSql);
            if( rc ) fatalError("cannot change description: %s", sqlite3_errmsg(db));
        }
        if( zInsSql ) {
            sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
                                    readfileFunc, 0, 0);
            rc = sqlite3_prepare_v2(db, zInsSql, -1, &pStmt, 0);
            if( rc ) fatalError("cannot prepare statement [%s]: %s",
                                    zInsSql, sqlite3_errmsg(db));
            rc = sqlite3_exec(db, "BEGIN", 0, 0, 0);
            if( rc ) fatalError("cannot start a transaction");
            for(i=iFirstInsArg; i<argc; i++) {
                sqlite3_bind_text(pStmt, 1, argv[i], -1, SQLITE_STATIC);
                sqlite3_step(pStmt);
                rc = sqlite3_reset(pStmt);
                if( rc ) fatalError("insert failed for %s", argv[i]);
            }
            sqlite3_finalize(pStmt);
            rc = sqlite3_exec(db, "COMMIT", 0, 0, 0);
            if( rc ) fatalError("cannot commit the transaction: %s", sqlite3_errmsg(db));
            rebuild_database(db);
            sqlite3_close(db);
            return 0;
        }
        if( zExpDb!=0 || zExpSql!=0 ) {
            sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
                                    writefileFunc, 0, 0);
            if( zExpDb!=0 ) {
                const char *zExDb =
                    "SELECT writefile(printf('%s/db%06d.db',?1,dbid),dbcontent),"
                    "       dbid, printf('%s/db%06d.db',?1,dbid), length(dbcontent)"
                    "  FROM db WHERE ?2<0 OR dbid=?2;";
                rc = sqlite3_prepare_v2(db, zExDb, -1, &pStmt, 0);
                if( rc ) fatalError("cannot prepare statement [%s]: %s",
                                        zExDb, sqlite3_errmsg(db));
                sqlite3_bind_text64(pStmt, 1, zExpDb, strlen(zExpDb),
                                    SQLITE_STATIC, SQLITE_UTF8);
                sqlite3_bind_int(pStmt, 2, onlyDbid);
                while( sqlite3_step(pStmt)==SQLITE_ROW ) {
                    printf("write db-%d (%d bytes) into %s\n",
                           sqlite3_column_int(pStmt,1),
                           sqlite3_column_int(pStmt,3),
                           sqlite3_column_text(pStmt,2));
                }
                sqlite3_finalize(pStmt);
            }
            if( zExpSql!=0 ) {
                const char *zExSql =
                    "SELECT writefile(printf('%s/sql%06d.txt',?1,sqlid),sqltext),"
                    "       sqlid, printf('%s/sql%06d.txt',?1,sqlid), length(sqltext)"
                    "  FROM xsql WHERE ?2<0 OR sqlid=?2;";
                rc = sqlite3_prepare_v2(db, zExSql, -1, &pStmt, 0);
                if( rc ) fatalError("cannot prepare statement [%s]: %s",
                                        zExSql, sqlite3_errmsg(db));
                sqlite3_bind_text64(pStmt, 1, zExpSql, strlen(zExpSql),
                                    SQLITE_STATIC, SQLITE_UTF8);
                sqlite3_bind_int(pStmt, 2, onlySqlid);
                while( sqlite3_step(pStmt)==SQLITE_ROW ) {
                    printf("write sql-%d (%d bytes) into %s\n",
                           sqlite3_column_int(pStmt,1),
                           sqlite3_column_int(pStmt,3),
                           sqlite3_column_text(pStmt,2));
                }
                sqlite3_finalize(pStmt);
            }
            sqlite3_close(db);
            return 0;
        }

        /* Load all SQL script content and all initial database images from the
        ** source db
        */
        blobListLoadFromDb(db, "SELECT sqlid, sqltext FROM xsql", onlySqlid,
                           &g.nSql, &g.pFirstSql);
        if( g.nSql==0 ) fatalError("need at least one SQL script");
        blobListLoadFromDb(db, "SELECT dbid, dbcontent FROM db", onlyDbid,
                           &g.nDb, &g.pFirstDb);
        if( g.nDb==0 ) {
            g.pFirstDb = safe_realloc(0, sizeof(Blob));
            memset(g.pFirstDb, 0, sizeof(Blob));
            g.pFirstDb->id = 1;
            g.pFirstDb->seq = 0;
            g.nDb = 1;
            sqlFuzz = 1;
        }

        /* Print the description, if there is one */
        if( !quietFlag ) {
            zDbName = azSrcDb[iSrcDb];
            i = (int)strlen(zDbName) - 1;
            while( i>0 && zDbName[i-1]!='/' && zDbName[i-1]!='\\' ) {
                i--;
            }
            zDbName += i;
            sqlite3_prepare_v2(db, "SELECT msg FROM readme", -1, &pStmt, 0);
            if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ) {
                printf("%s: %s\n", zDbName, sqlite3_column_text(pStmt,0));
            }
            sqlite3_finalize(pStmt);
        }

        /* Rebuild the database, if requested */
        if( rebuildFlag ) {
            if( !quietFlag ) {
                printf("%s: rebuilding... ", zDbName);
                fflush(stdout);
            }
            rebuild_database(db);
            if( !quietFlag ) printf("done\n");
        }

        /* Close the source database.  Verify that no SQLite memory allocations are
        ** outstanding.
        */
        sqlite3_close(db);
        if( sqlite3_memory_used()>0 ) {
            fatalError("SQLite has memory in use before the start of testing");
        }

        /* Limit available memory, if requested */
        if( nMem>0 ) {
            sqlite3_shutdown();
            pHeap = malloc(nMem);
            if( pHeap==0 ) {
                fatalError("failed to allocate %d bytes of heap memory", nMem);
            }
            sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMem, 128);
        }

        /* Register the in-memory virtual filesystem
        */
        formatVfs();
        inmemVfsRegister();

        /* Run a test using each SQL script against each database.
        */
        if( !verboseFlag && !quietFlag ) printf("%s:", zDbName);
        for(pSql=g.pFirstSql; pSql; pSql=pSql->pNext) {
            for(pDb=g.pFirstDb; pDb; pDb=pDb->pNext) {
                int openFlags;
                const char *zVfs = "inmem";
                sqlite3_snprintf(sizeof(g.zTestName), g.zTestName, "sqlid=%d,dbid=%d",
                                 pSql->id, pDb->id);
                if( verboseFlag ) {
                    printf("%s\n", g.zTestName);
                    fflush(stdout);
                } else if( !quietFlag ) {
                    static int prevAmt = -1;
                    int idx = pSql->seq*g.nDb + pDb->id - 1;
                    int amt = idx*10/(g.nDb*g.nSql);
                    if( amt!=prevAmt ) {
                        printf(" %d%%", amt*10);
                        fflush(stdout);
                        prevAmt = amt;
                    }
                }
                createVFile("main.db", pDb->sz, pDb->a);
                openFlags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
                if( nativeFlag && pDb->sz==0 ) {
                    openFlags |= SQLITE_OPEN_MEMORY;
                    zVfs = 0;
                }
                rc = sqlite3_open_v2("main.db", &db, openFlags, zVfs);
                if( rc ) fatalError("cannot open inmem database");
                if( cellSzCkFlag ) runSql(db, "PRAGMA cell_size_check=ON", runFlags);
                setAlarm(iTimeout);
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
                if( sqlFuzz || vdbeLimitFlag ) {
                    sqlite3_progress_handler(db, 100000, progressHandler, &vdbeLimitFlag);
                }
#endif
                do {
                    runSql(db, (char*)pSql->a, runFlags);
                } while( timeoutTest );
                setAlarm(0);
                sqlite3_close(db);
                if( sqlite3_memory_used()>0 ) fatalError("memory leak");
                reformatVfs();
                nTest++;
                g.zTestName[0] = 0;

                /* Simulate an error if the TEST_FAILURE environment variable is "5".
                ** This is used to verify that automated test script really do spot
                ** errors that occur in this test program.
                */
                if( zFailCode ) {
                    if( zFailCode[0]=='5' && zFailCode[1]==0 ) {
                        fatalError("simulated failure");
                    } else if( zFailCode[0]!=0 ) {
                        /* If TEST_FAILURE is something other than 5, just exit the test
                        ** early */
                        printf("\nExit early due to TEST_FAILURE being set\n");
                        iSrcDb = nSrcDb-1;
                        goto sourcedb_cleanup;
                    }
                }
            }
        }
        if( !quietFlag && !verboseFlag ) {
            printf(" 100%% - %d tests\n", g.nDb*g.nSql);
        }

        /* Clean up at the end of processing a single source database
        */
sourcedb_cleanup:
        blobListFree(g.pFirstSql);
        blobListFree(g.pFirstDb);
        reformatVfs();

    } /* End loop over all source databases */

    if( !quietFlag ) {
        sqlite3_int64 iElapse = timeOfDay() - iBegin;
        printf("fuzzcheck: 0 errors out of %d tests in %d.%03d seconds\n"
               "SQLite %s %s\n",
               nTest, (int)(iElapse/1000), (int)(iElapse%1000),
               sqlite3_libversion(), sqlite3_sourceid());
    }
    free(azSrcDb);
    free(pHeap);
    return 0;
}
Example #8
0
extern void setup_sqlite() {
     int           i;
     sqlite3_stmt *stmt = (sqlite3_stmt *)NULL;
     char         *ztail = (char *)NULL;
     char         *create[] = {"pragma foreign_keys=true",
                               "create table decks"
                               " (deckid integer primary key not null,"
                               "  filename  varchar(250) not null,"
                               "  shortname varchar(30)  not null,"
                               " constraint slides_uq unique(filename))",
                               "create table slides"
                               " (slideid integer primary key not null,"
                               "  deckid    int not null,"
                               "  slidenum  int not null,"
                               " constraint slides_uq unique(deckid,"
                               "                             slidenum),"
                               " constraint slides_fk"
                               "        foreign key(deckid)"
                               "        references decks(deckid))",
                               "create table words"
                               " (word      varchar(60) not null,"
                               "  kw        char(1) not null default 'N',"
                               "  slideid   int not null,"
                               "  counter   int not null default 1,"
                               "  origin    char(1) not null,"
                               "  stem      varchar(30),"
                               " constraint words_pk primary key(word,"
                               "       slideid,origin),"
                               " constraint words_fk"
                               "        foreign key(slideid)"
                               "        references slides(slideid))",
                               "create index words_idx"
                               " on words(slideid,word)",
                               "create index words_idx2"
                               " on words(stem)",
                               NULL};
    
     if (sqlite3_open(":memory:", &G_db) != SQLITE_OK) {
        fprintf(stderr, "sqlite3_open: %s\n", (char *)sqlite3_errmsg(G_db));
        exit(1);
     }
     i = 0;
     while (create[i]) {
       if ((sqlite3_prepare(G_db,
                            (const char *)create[i],
                            -1,
                            &stmt,
                            (const char **)&ztail) != SQLITE_OK)
            || (sqlite3_step(stmt) != SQLITE_DONE)) {
         fprintf(stderr, "%s: %s\n",
                         create[i],
                         (char *)sqlite3_errmsg(G_db));
         (void)sqlite3_close(G_db);
         exit(1);
       }
       (void)sqlite3_finalize(stmt);
       i++;
     } 
     // Prepare statements that will be repeatedly executed
     if ((sqlite3_prepare(G_db,
                          "insert into decks(filename,shortname)"
                          "values(?,lower(?))",
                          -1,
                          &G_ins_deck,
                          (const char **)&ztail) != SQLITE_OK)
         || (sqlite3_prepare(G_db,
                          "insert or ignore into slides(deckid,slidenum)"
                          "values(?,?)",
                          -1,
                          &G_ins_slide,
                          (const char **)&ztail) != SQLITE_OK)
         || (sqlite3_prepare(G_db,
                          "select slideid from slides"
                          " where deckid=? and slidenum=?",
                          -1,
                          &G_sel_slide,
                          (const char **)&ztail) != SQLITE_OK)
         || (sqlite3_prepare(G_db,
                          "insert into words(word,slideid,origin,kw)"
                          "values(lower(trim(?)),?,upper(char(?)),"
                          "case ? when 0 then 'N' else 'Y' end)",
                          -1,
                          &G_ins_word,
                          (const char **)&ztail) != SQLITE_OK)
         || (sqlite3_prepare(G_db,
                          "insert into words(word,slideid,origin,kw)"
                          "values(trim(?),?,upper(char(?)),"
                          "case ? when 0 then 'N' else 'Y' end)",
                          -1,
                          &G_ins_word_as_is,
                          (const char **)&ztail) != SQLITE_OK)
         || (sqlite3_prepare(G_db,
                          "update words set counter=counter+1"
                          " where word=lower(trim(?))"
                          " and slideid=?"
                          " and origin=upper(?)",
                          -1,
                          &G_upd_word,
                          (const char **)&ztail) != SQLITE_OK)
         || (sqlite3_prepare(G_db,
                          "update words set counter=counter+1"
                          " where word=trim(?)"
                          " and slideid=?"
                          " and origin=upper(?)",
                          -1,
                          &G_upd_word_as_is,
                          (const char **)&ztail) != SQLITE_OK)) {
       fprintf(stderr, "insert/update: %s\n",
                       (char *)sqlite3_errmsg(G_db));
       (void)sqlite3_close(G_db);
       exit(1);
     }
     atexit(finalize_sqlite);
}
Example #9
0
void initializeTags(void * mainCache)
{
	MUTEX_CREATE(concurentColdUpdate);
	
	sqlite3 * coldDB = NULL;
	
	//Create the tables in the main cache
	createTagsTable(mainCache);
	
	if((!checkFileExist(TAG_DB) || sqlite3_open(TAG_DB , &coldDB) != SQLITE_OK) && (!checkFileExist(WIP_TAG_DB) || sqlite3_open(WIP_TAG_DB, &coldDB) != SQLITE_OK))
	{
		//Error, we should reset it with the version we ship with then trigger an update
		resetTagsToLocal();
		
		if(!checkFileExist(TAG_DB) || sqlite3_open(TAG_DB , &coldDB) != SQLITE_OK)
		{
			alertExit("We have significant issues setting up our environment, this may be caused by permission issues, please contact us at contact@rakshata.com");
		}
	}
	
	sqlite3_stmt * requestRead, *requestWrite;
	
	//Build the tag base
	if((requestRead = createRequest(coldDB, "SELECT "DBNAMETOID(RDB_tagID)", "DBNAMETOID(RDB_tagName)" FROM "TABLE_TAGS)) != NULL)
	{
		requestWrite = tagUpdateQuery(mainCache, false);
		
		if(requestWrite != NULL)
		{
			while(sqlite3_step(requestRead) == SQLITE_ROW)
			{
				sqlite3_bind_int(requestWrite, 1, sqlite3_column_int(requestRead, 0));
				sqlite3_bind_text(requestWrite, 2, (void *) sqlite3_column_text(requestRead, 1), -1, SQLITE_STATIC);
				
				if(sqlite3_step(requestWrite) != SQLITE_DONE)
				{
#ifdef EXTENSIVE_LOGGING
					uint ID = (uint32_t) sqlite3_column_int(requestRead, 0);
					const unsigned char * text = sqlite3_column_text(requestRead, 1);
					
					if(text == NULL)
						logR("Error building the tag DB for ID %d: no text!", ID);
					else
						logR("Error building the tag DB for ID %d of text %s!", ID, text);
#endif
				}
				sqlite3_reset(requestWrite);
			}
			destroyRequest(requestWrite);
		}
		destroyRequest(requestRead);
	}
	
	//Build the category base
	if((requestRead = createRequest(coldDB, "SELECT "DBNAMETOID(RDB_CAT_ID)", "DBNAMETOID(RDB_CAT_rootID)", "DBNAMETOID(RDB_CAT_name)" FROM "TABLE_CATEGORY)) != NULL)
	{
		requestWrite = catUpdateQuery(mainCache, false);
		
		if(requestWrite != NULL)
		{
			
			while(sqlite3_step(requestRead) == SQLITE_ROW)
			{
				sqlite3_bind_int(requestWrite, 1, sqlite3_column_int(requestRead, 0));
				sqlite3_bind_int(requestWrite, 2, sqlite3_column_int(requestRead, 1));
				sqlite3_bind_text(requestWrite, 3, (void *) sqlite3_column_text(requestRead, 2), -1, SQLITE_STATIC);
				
				for(byte i = 0; i < 32; i++)
				{
					sqlite3_bind_int(requestWrite, i + 4, sqlite3_column_int(requestRead, i + 3));
				}
				
				if(sqlite3_step(requestWrite) != SQLITE_DONE)
				{
#ifdef EXTENSIVE_LOGGING
					uint ID = (uint32_t) sqlite3_column_int(requestRead, 0);
					const unsigned char * text = sqlite3_column_text(requestRead, 2);
					
					if(text == NULL)
						logR("Error building the category DB for ID %d: no text!", ID);
					else
						logR("Error building the category DB for ID %d of text %s!", ID, text);
#endif
				}
				sqlite3_reset(requestWrite);
			}
			destroyRequest(requestWrite);
		}
		destroyRequest(requestRead);
	}
	sqlite3_close(coldDB);
}
Example #10
0
int main( const int argc, const char const *argv[] )
{
     const char           *rom1_filename;
     const char           *rom2_filename;
     const char           *db_filename;
     /**/  organization_s *organization;
     /**/  schedule_s     *schedule;
     /**/  tsbrom_s       *rom1;
     /**/  tsbrom_s       *rom2;
     /**/  sqlite3        *db;
     /**/  char            rom1_output_file     [FILENAME_MAX + 1] = { 0 };
     /**/  char            rom2_output_file     [FILENAME_MAX + 1] = { 0 };
     /**/  char            schedule_output_file [FILENAME_MAX + 1] = { 0 };

     if ( argc < 4 )
     {
          printf( "Usage %s <rom1> <rom2> <database> <output path>\n", argv[0] );

          return EXIT_SUCCESS;
     }

     rom1_filename = argv[1];
     rom2_filename = argv[2];
     db_filename   = argv[3];

     sprintf( rom1_output_file,     "%s/ncfo1.nes",    argv[4] );
     sprintf( rom2_output_file,     "%s/ncfo2.nes",    argv[4] );
     sprintf( schedule_output_file, "%s/schedule.csv", argv[4] );

     srand( time( NULL ) );

     if ( (rom1 = readTsbRom( rom1_filename )) == NULL )
     {
          printf( "Unable to open rom 1: %s\n", getFileUtilsError() );

          return EXIT_FAILURE;
     }

     if ( (rom2 = readTsbRom( rom2_filename )) == NULL )
     {
          printf( "Unable to open rom 2: %s\n", getFileUtilsError() );

          free( rom1 );

          return EXIT_FAILURE;
     }

     sqlite3_open( db_filename, &db );

     if ( (organization = get_organization( db, 1 )) == NULL )
     {
          printf( "Unable to retrieve organization data from database.\n" );

          free( rom1 );
          free( rom2 );

          sqlite3_close( db );

          return EXIT_FAILURE;
     }

     if ( ! populateRoms( rom1, rom2, organization ) )
     {
          printf( "Error populating roms: %s\n", getPopulateRomsError() );

          free( rom1 );
          free( rom2 );
          free_organization( organization );

          sqlite3_close( db );

          return EXIT_FAILURE;
     }

     injectSeason( rom1, organization->season );
     injectSeason( rom2, organization->season );

     if ( (schedule = generateSchedule( rom1, rom2 )) == NULL )
     {
          printf( "Error generating schedule: %s\n", getGenerateScheduleError() );

          free( rom1 );
          free( rom2 );
          free_organization( organization );

          sqlite3_close( db );

          return EXIT_FAILURE;
     }

     printf( "Creating TSB Rom File %s\n", rom1_output_file );

     if ( ! writeTsbRom( rom1_output_file, rom1 ) )
     {
          printf( "Unable to write to file %s: %s\n", rom1_output_file, getFileUtilsError() );

          free( rom1 );
          free( rom2 );
          freeSchedule( schedule );
          free_organization( organization );

          sqlite3_close( db );

          return EXIT_FAILURE;
     }

     printf( "Creating TSB Rom File %s\n", rom2_output_file );

     if ( ! writeTsbRom( rom2_output_file, rom2 ) )
     {
          printf( "Unable to write to file %s: %s\n", rom2_output_file, getFileUtilsError() );

          free( rom1 );
          free( rom2 );
          freeSchedule( schedule );
          free_organization( organization );

          sqlite3_close( db );

          return EXIT_FAILURE;
     }

     printf( "Creating Schedule File %s\n", schedule_output_file );

     if ( ! writeSchedule( schedule_output_file, schedule ) )
     {
          printf( "Unable to write to file %s: %s\n", schedule_output_file, getFileUtilsError() );

          free( rom1 );
          free( rom2 );
          freeSchedule( schedule );
          free_organization( organization );

          sqlite3_close( db );

          return EXIT_FAILURE;
     }

     free( rom1 );
     free( rom2 );
     freeSchedule( schedule );
     free_organization( organization );

     sqlite3_close( db );

     return EXIT_SUCCESS;
}
int main()
{
	int ret;
	sqlite3 *disk_db = NULL;

	fprintf(stderr,
		"Opening disk database and trying to create the in memory database\n");
	ret =
	    sqlite3_open_v2("autocomplete.sqlite", &disk_db, SQLITE_OPEN_READONLY,
			    NULL);
	if (SQLITE_OK != ret) {
		printf("Error opening database: %s\n", sqlite3_errmsg(disk_db));
		goto end;
	}

	ret = sqlite3_open(":memory:", &db);
	if (SQLITE_OK != ret) {
		if (db == NULL)
			fprintf(stderr, "Insufficient Memory\n");
		else
			printf("Error opening database: %s\n",
			       sqlite3_errmsg(db));
		goto close_and_end;
	}

	char *err;
	ret =
	    sqlite3_exec(db,
			 "CREATE TABLE autocomplete (english TEXT COLLATE NOCASE, tamil TEXT COLLATE NOCASE, score int)",
			 NULL, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error creating sqlite table: %s\n", sqlite3_errmsg(db));
		goto close_and_end;
	}

	ret =
	    sqlite3_prepare_v2(db, "INSERT INTO autocomplete VALUES (?, ?, ?)",
			       -1, &stmt, NULL);
	if (SQLITE_OK != ret) {
		printf("Error creating prepared statement: %s\n",
		       sqlite3_errmsg(db));
		goto close_and_end;
	}

	ret = sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error beginning a transaction: %s\n",
		       sqlite3_errmsg(db));
		goto close_and_end;
	}

	/* Select each record from the disk db and insert into the in-memory table */
	ret =
	    sqlite3_exec(disk_db,
			 "SELECT english, tamil, score FROM autocomplete",
			 disk_to_mem_cb, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error conversion of disk_to_mem: %s\n",
		       sqlite3_errmsg(db));
		goto close_and_end;
	}

	ret = sqlite3_exec(db, "COMMIT", NULL, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error committing a transaction: %s\n",
		       sqlite3_errmsg(db));
		goto close_and_end;
	}
	sqlite3_finalize(stmt);
	sqlite3_close(disk_db);

	fprintf(stderr, "In-memory database creation complete. About to create Indexes.\n");

	/* Create Indexes */
	fprintf(stderr, "Data inserted into tables. About to create english index\n");
	ret = sqlite3_exec(db, "CREATE INDEX english_idx ON autocomplete (english)", NULL, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error creating an index for the english column: %s\n",
		       sqlite3_errmsg(db));
	}

	fprintf(stderr, "Index created for english. Now creating index for english + tamil\n");
	ret = sqlite3_exec(db, "CREATE INDEX eng_tam_idx ON autocomplete (english, tamil)", NULL, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error creating an index for the english+tamil columns: %s\n",
		       sqlite3_errmsg(db));
	}

	fprintf(stderr, "Index created for english + tamil. Now creating index for english + tamil + score\n");
	ret = sqlite3_exec(db, "CREATE INDEX eng_tam_score_idx ON autocomplete (english, tamil, score)", NULL, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error creating an index for the english+tamil+score columns: %s\n",
		       sqlite3_errmsg(db));
	}

	fprintf(stderr, "Index created for english + tamil + score. Now creating index for english + score\n");
	ret = sqlite3_exec(db, "CREATE INDEX english_score_idx ON autocomplete (english, score)", NULL, NULL, &err);
	if (SQLITE_OK != ret) {
		printf("Error creating an index for the english+tamil+score columns: %s\n",
		       sqlite3_errmsg(db));
	}

	ret =
	    sqlite3_prepare_v2(db,
			       "SELECT DISTINCT tamil FROM autocomplete WHERE english LIKE ? ORDER BY score DESC LIMIT 5",
			       -1, &stmt, NULL);

	if (SQLITE_OK != ret) {
		printf("Error creating prepared statement: %s\n",
		       sqlite3_errmsg(db));
		goto close_and_end;
	}

	GtkWidget *window;

	gtk_init(NULL, NULL);
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), "Vaiyakani");

	entry = gtk_entry_new();
	suggestions = gtk_label_new("");

	GtkWidget *box;
	box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);

	gtk_container_add(GTK_CONTAINER(box), entry);
	gtk_container_add(GTK_CONTAINER(box), suggestions);

	gtk_container_add(GTK_CONTAINER(window), box);
	g_signal_connect(entry, "changed", kb, NULL);

	gtk_widget_show_all(window);
	gtk_main();

	sqlite3_finalize(stmt);

close_and_end:
	if (disk_db)
		sqlite3_close(disk_db);
	if (db)
		sqlite3_close(db);
end:
	return ret;
}
static gboolean
load_database (GsPlugin *plugin, GCancellable *cancellable, GError **error)
{
	GsPluginData *priv = gs_plugin_get_data (plugin);
	const gchar *statement;
	gboolean rebuild_ratings = FALSE;
	char *error_msg = NULL;
	gint result;
	gint64 stats_mtime = 0;
	gint64 now;
	g_autoptr(GError) error_local = NULL;

	g_debug ("trying to open database '%s'", priv->db_path);
	if (!gs_mkdir_parent (priv->db_path, error))
		return FALSE;
	result = sqlite3_open (priv->db_path, &priv->db);
	if (result != SQLITE_OK) {
		g_set_error (error,
			     GS_PLUGIN_ERROR,
			     GS_PLUGIN_ERROR_FAILED,
			     "Can't open Ubuntu review statistics database: %s",
			     sqlite3_errmsg (priv->db));
		return FALSE;
	}

	/* We don't need to keep doing fsync */
	sqlite3_exec (priv->db, "PRAGMA synchronous=OFF",
		      NULL, NULL, NULL);

	/* Create a table to store the stats */
	result = sqlite3_exec (priv->db, "SELECT * FROM review_stats LIMIT 1", NULL, NULL, &error_msg);
	if (result != SQLITE_OK) {
		g_debug ("creating table to repair: %s", error_msg);
		sqlite3_free (error_msg);
		statement = "CREATE TABLE review_stats ("
			    "package_name TEXT PRIMARY KEY,"
			    "one_star_count INTEGER DEFAULT 0,"
			    "two_star_count INTEGER DEFAULT 0,"
			    "three_star_count INTEGER DEFAULT 0,"
			    "four_star_count INTEGER DEFAULT 0,"
			    "five_star_count INTEGER DEFAULT 0);";
		sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
		rebuild_ratings = TRUE;
	}

	/* Create a table to store local reviews */
	result = sqlite3_exec (priv->db, "SELECT * FROM reviews LIMIT 1", NULL, NULL, &error_msg);
	if (result != SQLITE_OK) {
		g_debug ("creating table to repair: %s", error_msg);
		sqlite3_free (error_msg);
		statement = "CREATE TABLE reviews ("
			    "package_name TEXT PRIMARY KEY,"
			    "id TEXT,"
			    "version TEXT,"
			    "date TEXT,"
			    "rating INTEGER,"
			    "summary TEXT,"
			    "text TEXT);";
		sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
		rebuild_ratings = TRUE;
	}

	/* Create a table to store timestamps */
	result = sqlite3_exec (priv->db,
			       "SELECT value FROM timestamps WHERE key = 'stats_mtime' LIMIT 1",
			       get_timestamp_sqlite_cb, &stats_mtime,
			       &error_msg);
	if (result != SQLITE_OK) {
		g_debug ("creating table to repair: %s", error_msg);
		sqlite3_free (error_msg);
		statement = "CREATE TABLE timestamps ("
			    "key TEXT PRIMARY KEY,"
			    "value INTEGER DEFAULT 0);";
		sqlite3_exec (priv->db, statement, NULL, NULL, NULL);

		/* Set the time of database creation */
		if (!set_timestamp (plugin, "stats_ctime", error))
			return FALSE;
	}

	/* Download data if we have none or it is out of date */
	now = g_get_real_time () / G_USEC_PER_SEC;
	if (stats_mtime == 0 || rebuild_ratings) {
		g_debug ("No Ubuntu review statistics");
		if (!download_review_stats (plugin, cancellable, &error_local)) {
			g_warning ("Failed to get Ubuntu review statistics: %s",
				   error_local->message);
			return TRUE;
		}
	} else if (now - stats_mtime > REVIEW_STATS_AGE_MAX) {
		g_debug ("Ubuntu review statistics was %" G_GINT64_FORMAT
			 " days old, so regetting",
			 (now - stats_mtime) / ( 60 * 60 * 24));
		if (!download_review_stats (plugin, cancellable, error))
			return FALSE;
	} else {
		g_debug ("Ubuntu review statistics %" G_GINT64_FORMAT
			 " days old, so no need to redownload",
			 (now - stats_mtime) / ( 60 * 60 * 24));
	}
	return TRUE;
}
int main(int argc, char **argv) {
    const char * const db_location = "cluster.sqlite";
    const char * const select_query = "SELECT document_identifier, label FROM temporary_label_clustering ORDER BY document_identifier";
    QUADTREE *tree = NULL;
    sqlite3 *db = NULL;
    char *zErrMsg = NULL;
    int rc = 0;
    uint64_t *validation, *verification;
    unsigned int label_buf[MAX_LABEL_COUNT];
    struct verification_t v;

    // Allocate some memory for those things
    validation = calloc(sizeof(uint64_t), DOCUMENT_IDENTIFIER_COUNT * (MAX_LABEL_COUNT + 1));
    verification = calloc(sizeof(uint64_t), DOCUMENT_IDENTIFIER_COUNT * (MAX_LABEL_COUNT + 1));
    if (validation == NULL || verification == NULL) {
        fprintf(stderr, "Allocation error!\n");
        return 1;
    }

    v.arr = validation;
    v.last_offset = 0;

    // Open the database
    rc = sqlite3_open(db_location, &db);
    if (rc) {
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
        sqlite3_close(db);
        return 1;
    }

    // Instantiate the quadtree
    assert(!quadtree_init(&tree, nextpow2(MAX_DOCUMENT_IDENTIFIER)-1, nextpow2(MAX_DOCUMENT_IDENTIFIER)-1));

    // Select the data out of the database
    fprintf(stderr, "Creating quadtree...\n");
    rc = sqlite3_exec(db, select_query, create_tree_callback, tree, &zErrMsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL error: %s\n", zErrMsg);
        sqlite3_free(zErrMsg);
        sqlite3_close(db);
        return 1;
    }

    // Create the validation structure
    fprintf(stderr, "Creating validation structure...\n");
    rc = sqlite3_exec(db, select_query, create_validation_callback, &v, &zErrMsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL error: %s\n", zErrMsg);
        sqlite3_free(zErrMsg);
        sqlite3_close(db);
        return 1;
    }

    // Verify the result
    fprintf(stderr, "Verifying (stage 1)...\n");
    for (int i = 0; i < DOCUMENT_IDENTIFIER_COUNT; i++) {
        uint64_t *off = validation + (i * (MAX_LABEL_COUNT + 1));
        uint64_t identifier = *off;
        unsigned int out = 0;
        assert(!quadtree_scan_x(tree, identifier, label_buf, &out, MAX_LABEL_COUNT));
        for (int j = 0; j < out; j++) {
            unsigned int label = label_buf[j];
            for (int k = 1; k < MAX_LABEL_COUNT; k++) {
                if (*(off + k) == label) {
                    *(off + k) = 0;
                }
            }
        }
    }

    fprintf(stderr, "Verifying (stage 2)...\n");
    for (int i = 0; i < DOCUMENT_IDENTIFIER_COUNT; i++) {
        uint64_t *off = validation + (i * (MAX_LABEL_COUNT + 1));
        uint64_t passed = 1;
        for (int j = 1; j < MAX_LABEL_COUNT; j++) {
            uint64_t *suboff = off + j;
            if (*suboff) {
                passed = 0;
                fprintf(stderr, "%d/%d/%d/%d\n", *off, *suboff, i, j);
                assert(0);
            }
        }
        if (passed) {
            *off = 0;
        }
    }

    fprintf(stderr, "Verifying (stage 3)...\n");
    assert(!memcmp(validation, verification, DOCUMENT_IDENTIFIER_COUNT * (MAX_LABEL_COUNT + 1) * sizeof(uint64_t)));

    return 0;
}
Operacoes::GetResult() {
    //Pronto :)
    //Mais alguma coisa?
    char *sql, *end;
    int retval, i;
    int q_cnt = 5, q_size = 150;
    char **queries = malloc(sizeof (char) * q_cnt * q_size);
    char valida_name[11];
    // definindo ponteiros
    sqlite3_stmt *stmt;
    sqlite3 *handle;
    // abrindo seu banco, antes de rodar o programa crie um banco com SQLite
    retval = sqlite3_open("POO", &handle);
    // caso de erro na conexão vai mostrar msg
    if (retval) {
        /** Erro no banco **/
    }
    int result;
    sql = (char *) malloc(sizeof (char) * q_size);
             /*! \brief Cadastra Usuário No BD
     *
     *
     * Recebe o objeto User e apartir dele é gerado uma linha no BD, no entanto isso só ocorre caso\n
     * não exista nem um indentificador nem um nome igual na tabela
     */
    if (currentAction == TYPES::ACTION_LIST::CADASTRAUSER) {
        Operacoes.CriaUser(sql, retval, handle);
    }        /*! \brief Atualiza Usuário No BD
             *
             *
             * Recebe o objeto User e apartir dele são atualizados o nome e a senha, se existir um identificador e o novo nome não
             * existir ainda.
             */
    else if (currentAction == TYPES::ACTION_LIST::UPDATEUSER) {
        Operacoes.UpdateUser(sql, retval, handle);
    }
             /*! \brief Deleta Usuário No BD
         *
         *
         * Recebe o objeto endereço que deve ser deletado e apartir dele faz um drop Delete na linha 
         */
    else if (currentAction == TYPES::ACTION_LIST::DELETEUSER) {
        Operacoes.DeleteUser(sql, retval, handle);
    }        /*! \brief Procura um nome de Usuário No BD
             *
             *
             * Recebe um Name e procura na tabela se esse existe, caso sim armazena as informações dele em um objeto User 
             */
    else if (currentAction == TYPES::ACTION_LIST::FINDUSERN) {
        Operacoes.FindUserN(sql, retval, handle, queries, stmt);
    }        /*! \brief Procura um id de Usuário No BD
        *
        *
        * Recebe um identificador e procura na tabela se esse existe, caso sim armazena as informações dele em um objeto User 
        */
    else if (currentAction == TYPES::ACTION_LIST::FINDUSERID) {
        Operacoes.FindUserID(sql, retval, handle, queries, stmt);
    }        /*! \brief Cadastra Comentário No BD
             *
             *
             * Recebe o objeto Coment e apartir dele é gerado uma linha no BD, no entanto isso só ocorre caso\n
             * não exista o identificador do comentário na tabela
             */
    else if (currentAction == TYPES::ACTION_LIST::CADASTRACOMENT) {
        Operacoes.CriaComent(sql, retval, handle);
    }        /*! \brief Atualiza Comentário No BD
             *
             *
             * Recebe o objeto Coment e apartir dele é gerado uma linha no BD, no entanto isso só ocorre caso\n
             * não exista o identificador do comentário na tabela
             */
    else if (currentAction == TYPES::ACTION_LIST::UPDATECOMENT) {
        Operacoes.UpdateComent(sql, retval, handle);
    }        /*! \brief Deleta Comentário No BD
             *
             *
             * Recebe o id de um Comentário e apartir dele é feito um delete na linha caso essa exista.
             */
    else if (currentAction == TYPES::ACTION_LIST::DELETECOMENT) {
        //Delete na entidade no BD            
        Operacoes.DeleteComent(sql, retval, handle);
    }        /*! \brief Procura um id de Comentário No BD
             *
             *
             * Recebe o id de busca e caso encontre coloca os valores da linha em um objeto Coment
             */
    else if (currentAction == TYPES::ACTION_LIST::FINDCOMENT) {
        Operacoes.FindComentID(sql, retval, handle, queries, stmt);
    }        /*! \brief Cadastra um Post No BD
             *
             *
             * Recebe o objeto Post e armazena no Banco de Dados, só armazena se o id do Post não existir
             */
    else if (currentAction == TYPES::ACTION_LIST::CADASTRAPOST) {
        Operacoes.CriaPost(sql, retval, handle);
    }        /*! \brief Atualiza um Post No BD
             *
             *
             * Recebe o id de um Post e atualiza seu texto, data e avaliação se esse post existir
             */
    else if (currentAction == TYPES::ACTION_LIST::UPDATEPOST) {
        Operacoes.UpdatePost(sql, retval, handle);
    }        /*! \brief Deleta um Post No BD
             *
             *
             * Recebe o id de um Post e deleta a linha em que ele se encontra
             */
    else if (currentAction == TYPES::ACTION_LIST::DELETEPOST) {
        Operacoes.DeletePost(sql, retval, handle);
    }        /*! \brief Encontra um Post pelo id No BD
             *
             *
             * Recebe o id de um Post e o armazena no objeto Post
             */
    else if (currentAction == TYPES::ACTION_LIST::FINDPOST) {
        Operacoes.FindPostID(sql, retval, handle, queries, stmt);
    }
    // fecha a conexão
    free(sql);
    sqlite3_close(handle);
    return result;
}
Example #15
0
/******************************************************************************
 *                                                                            *
 * Function: zbx_db_connect                                                   *
 *                                                                            *
 * Purpose: connect to the database                                           *
 *                                                                            *
 * Return value: ZBX_DB_OK - succefully connected                             *
 *               ZBX_DB_DOWN - database is down                               *
 *               ZBX_DB_FAIL - failed to connect                              *
 *                                                                            *
 ******************************************************************************/
int	zbx_db_connect(char *host, char *user, char *password, char *dbname, char *dbschema, char *dbsocket, int port)
{
	int		ret = ZBX_DB_OK;
#if defined(HAVE_IBM_DB2)
	char		*connect = NULL;
#elif defined(HAVE_ORACLE)
	char		*connect = NULL;
	sword		err = OCI_SUCCESS;
#elif defined(HAVE_POSTGRESQL)
	char		*cport = NULL;
	DB_RESULT	result;
	DB_ROW		row;
#endif

	txn_init = 1;

	assert(NULL != host);

#if defined(HAVE_IBM_DB2)
	connect = zbx_strdup(connect, "PROTOCOL=TCPIP;");
	if ('\0' != *host)
		connect = zbx_strdcatf(connect, "HOSTNAME=%s;", host);
	if (NULL != dbname && '\0' != *dbname)
		connect = zbx_strdcatf(connect, "DATABASE=%s;", dbname);
	if (0 != port)
		connect = zbx_strdcatf(connect, "PORT=%d;", port);
	if (NULL != user && '\0' != *user)
		connect = zbx_strdcatf(connect, "UID=%s;", user);
	if (NULL != password && '\0' != *password)
		connect = zbx_strdcatf(connect, "PWD=%s;", password);

	memset(&ibm_db2, 0, sizeof(ibm_db2));

	/* allocate an environment handle */
	if (SUCCEED != zbx_ibm_db2_success(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &ibm_db2.henv)))
		ret = ZBX_DB_FAIL;

	/* set attribute to enable application to run as ODBC 3.0 application; */
	/* recommended for pure IBM DB2 CLI, but not required */
	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLSetEnvAttr(ibm_db2.henv, SQL_ATTR_ODBC_VERSION,
			(void *)SQL_OV_ODBC3, 0)))
		ret = ZBX_DB_FAIL;

	/* allocate a database connection handle */
	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLAllocHandle(SQL_HANDLE_DBC, ibm_db2.henv,
			&ibm_db2.hdbc)))
		ret = ZBX_DB_FAIL;

	/* connect to the database */
	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLDriverConnect(ibm_db2.hdbc, NULL, (SQLCHAR *)connect,
			SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT)))
		ret = ZBX_DB_FAIL;

	/* set autocommit on */
  	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLSetConnectAttr(ibm_db2.hdbc, SQL_ATTR_AUTOCOMMIT,
								(SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS)))
		ret = ZBX_DB_DOWN;

	/* we do not generate vendor escape clause sequences */
  	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLSetConnectAttr(ibm_db2.hdbc, SQL_ATTR_NOSCAN,
								(SQLPOINTER)SQL_NOSCAN_ON, SQL_NTS)))
		ret = ZBX_DB_DOWN;

	/* set current schema */
	if (NULL != dbschema && '\0' != *dbschema && ZBX_DB_OK == ret)
	{
		char	*dbschema_esc;

		dbschema_esc = DBdyn_escape_string(dbschema);
		DBexecute("set current schema='%s'", dbschema_esc);
		zbx_free(dbschema_esc);
	}

	/* output error information */
	if (ZBX_DB_OK != ret)
	{
		zbx_ibm_db2_log_errors(SQL_HANDLE_ENV, ibm_db2.henv);
		zbx_ibm_db2_log_errors(SQL_HANDLE_DBC, ibm_db2.hdbc);

		zbx_db_close();
	}

	zbx_free(connect);
#elif defined(HAVE_MYSQL)
	conn = mysql_init(NULL);

	if (!mysql_real_connect(conn, host, user, password, dbname, port, dbsocket, CLIENT_MULTI_STATEMENTS))
	{
		zabbix_errlog(ERR_Z3001, dbname, mysql_errno(conn), mysql_error(conn));
		ret = ZBX_DB_FAIL;
	}

	if (ZBX_DB_OK == ret)
	{
		if (0 != mysql_select_db(conn, dbname))
		{
			zabbix_errlog(ERR_Z3001, dbname, mysql_errno(conn), mysql_error(conn));
			ret = ZBX_DB_FAIL;
		}
	}

	if (ZBX_DB_OK == ret)
	{
		DBexecute("set names utf8");
	}

	if (ZBX_DB_FAIL == ret)
	{
		switch (mysql_errno(conn))
		{
			case CR_CONN_HOST_ERROR:
			case CR_SERVER_GONE_ERROR:
			case CR_CONNECTION_ERROR:
			case CR_SERVER_LOST:
			case ER_SERVER_SHUTDOWN:
			case ER_ACCESS_DENIED_ERROR:		/* wrong user or password */
			case ER_ILLEGAL_GRANT_FOR_TABLE:	/* user without any privileges */
			case ER_TABLEACCESS_DENIED_ERROR:	/* user without some privilege */
			case ER_UNKNOWN_ERROR:
				ret = ZBX_DB_DOWN;
				break;
			default:
				break;
		}
	}
#elif defined(HAVE_ORACLE)
#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
	if (NULL == getenv("NLS_LANG"))
		putenv("NLS_LANG=.UTF8");
#endif
	memset(&oracle, 0, sizeof(oracle));

	/* connection string format: [//]host[:port][/service name] */

	if ('\0' != *host)
	{
		connect = zbx_strdcatf(connect, "//%s", host);
		if (0 != port)
			connect = zbx_strdcatf(connect, ":%d", port);
		if (NULL != dbname && '\0' != *dbname)
			connect = zbx_strdcatf(connect, "/%s", dbname);
	}
	else
		ret = ZBX_DB_FAIL;

	if (ZBX_DB_OK == ret)
	{
		/* initialize environment */
		err = OCIEnvCreate((OCIEnv **)&oracle.envhp, (ub4)OCI_DEFAULT,
				(dvoid *)0, (dvoid * (*)(dvoid *,size_t))0,
				(dvoid * (*)(dvoid *, dvoid *, size_t))0,
				(void (*)(dvoid *, dvoid *))0, (size_t)0, (dvoid **)0);

		if (OCI_SUCCESS != err)
		{
			zabbix_errlog(ERR_Z3001, connect, err, zbx_oci_error(err));
			ret = ZBX_DB_FAIL;
		}
	}

	if (ZBX_DB_OK == ret)
	{
		/* allocate an error handle */
		(void)OCIHandleAlloc((dvoid *)oracle.envhp, (dvoid **)&oracle.errhp, OCI_HTYPE_ERROR,
				(size_t)0, (dvoid **)0);

		/* get the session */
		err = OCILogon2(oracle.envhp, oracle.errhp, &oracle.svchp,
				(text *)user, (ub4)(NULL != user ? strlen(user) : 0),
				(text *)password, (ub4)(NULL != password ? strlen(password) : 0),
				(text *)connect, (ub4)strlen(connect),
				OCI_DEFAULT);

		if (OCI_SUCCESS != err)
		{
			zabbix_errlog(ERR_Z3001, connect, err, zbx_oci_error(err));
			ret = ZBX_DB_DOWN;
		}
		else
		{
			err = OCIAttrGet((void *)oracle.svchp, OCI_HTYPE_SVCCTX, (void *)&oracle.srvhp, (ub4 *)0,
					OCI_ATTR_SERVER, oracle.errhp);

			if (OCI_SUCCESS != err)
			{
				zabbix_errlog(ERR_Z3001, connect, err, zbx_oci_error(err));
				ret = ZBX_DB_DOWN;
			}
		}
	}

	zbx_free(connect);

	if (ZBX_DB_OK != ret)
		zbx_db_close();
#elif defined(HAVE_POSTGRESQL)
	if (0 != port)
		cport = zbx_dsprintf(cport, "%d", port);

	conn = PQsetdbLogin(host, cport, NULL, NULL, dbname, user, password);

	zbx_free(cport);

	/* check to see that the backend connection was successfully made */
	if (CONNECTION_OK != PQstatus(conn))
	{
		zabbix_errlog(ERR_Z3001, dbname, 0, PQerrorMessage(conn));
		ret = ZBX_DB_DOWN;
	}
	else
	{
		result = DBselect("select oid from pg_type where typname='bytea'");
		if (NULL != (row = DBfetch(result)))
			ZBX_PG_BYTEAOID = atoi(row[0]);
		DBfree_result(result);
	}

#ifdef HAVE_FUNCTION_PQSERVERVERSION
	ZBX_PG_SVERSION = PQserverVersion(conn);
	zabbix_log(LOG_LEVEL_DEBUG, "PostgreSQL Server version: %d", ZBX_PG_SVERSION);
#endif

	if (80100 <= ZBX_PG_SVERSION)
	{
		/* disable "nonstandard use of \' in a string literal" warning */
		DBexecute("set escape_string_warning to off");

		result = DBselect("show standard_conforming_strings");
		if (NULL != (row = DBfetch(result)))
			ZBX_PG_ESCAPE_BACKSLASH = (0 == strcmp(row[0], "off"));
		DBfree_result(result);
	}

	if (90000 <= ZBX_PG_SVERSION)
	{
		/* change the output format for values of type bytea from hex (the default) to escape */
		DBexecute("set bytea_output=escape");
	}
#elif defined(HAVE_SQLITE3)
#ifdef HAVE_FUNCTION_SQLITE3_OPEN_V2
	if (SQLITE_OK != sqlite3_open_v2(dbname, &conn, SQLITE_OPEN_READWRITE, NULL))
#else
	if (SQLITE_OK != sqlite3_open(dbname, &conn))
#endif
	{
		zabbix_errlog(ERR_Z3001, dbname, 0, sqlite3_errmsg(conn));
		sqlite3_close(conn);
		ret = ZBX_DB_DOWN;
	}
	else
	{
		char	*p, *path;

		/* do not return SQLITE_BUSY immediately, wait for N ms */
		sqlite3_busy_timeout(conn, SEC_PER_MIN * 1000);

		path = strdup(dbname);
		if (NULL != (p = strrchr(path, '/')))
			*++p = '\0';
		else
			*path = '\0';

		DBexecute("PRAGMA synchronous = 0");	/* OFF */
		DBexecute("PRAGMA temp_store = 2");	/* MEMORY */
		DBexecute("PRAGMA temp_store_directory = '%s'", path);

		zbx_free(path);
	}
#endif	/* HAVE_SQLITE3 */

	txn_init = 0;

	return ret;
}
Example #16
0
void disassemble(String filename){

	sqlite3 *db;
	sqlite3_stmt *res;
	const char *tail;
	int rc;

        //printf("IN DISASSEMBLE!\n");
	rc = sqlite3_open(DBNAME, &db);
	if (rc != SQLITE_OK){
		fprintf(stderr, "Can't open database %s!\n", sqlite3_errmsg(db));
		sqlite3_close(db);
		exit(1);
	}

	String query = "", root = "";
	sprintf(query, "Select mountpt from CacheContent where filename = '%s';", filename);
	int good = 0;
	while (!good){
		rc = sqlite3_prepare_v2(db, query, 1000, &res, &tail);
		if (rc != SQLITE_OK){
			//printf("Disassemble: SQL Error: %s\n", sqlite3_errmsg(db));
		}else {good = 1;}
	}
	if (sqlite3_step(res) == SQLITE_ROW){
		strcpy(root, sqlite3_column_text(res,0));
	}
	sqlite3_finalize(res);

	String volume = "";
	sprintf(query, "Select fileloc from VolContent where filename = '%s%s'", root, filename);
	good = 0;
  
	while (!good){
		rc = sqlite3_prepare_v2(db, query, 1000, &res, &tail);
		if (rc != SQLITE_OK){
			
		} else {good = 1;}
	}
	if (sqlite3_step(res) == SQLITE_ROW){
		strcpy(volume, sqlite3_column_text(res,0));
	}
        
	sqlite3_finalize(res);

	String mv = "";
	sprintf(mv, "mv '%s/%s' '%s/%s%s'", STORAGE_LOC, filename, volume, root, filename);
	system(mv);
	sqlite3_close(db);

	printf("[-] %s: %s\n", STORAGE_LOC, filename);

	FILE *fp1 = fopen("../file_transaction/assembled.txt", "rb");
        FILE *fp2 = fopen("../file_transaction/disassembled.txt", "ab");
        String line = "";
        while (fgets(line, sizeof(line), fp1) != NULL){
		String compare = "";
		strcpy(compare, filename);
		strcat(compare, "\n");
		if (strcmp(compare, line) != 0){ //remove assembled file from assembled txt
			fprintf(fp2, "%s", line);
		}
	}
	fclose(fp1);
	fclose(fp2);
	system("mv '../file_transaction/disassembled.txt' '../file_transaction/assembled.txt'");
}
Example #17
0
// filename passed here has part1.xxxx
// we remove part1 and select the root from cachecontent
// then we assemble by checking from volcontent the locations of the parts
// that is root/part%.filename
// file is placed in assembly loc
// orig file is placed in cvfsstore
// should we update link in share or is that auto?
void assemble(String filename){
   char *err = 0;

   String comm, query, tempname;

   int rc;

   sqlite3 *db;
   sqlite3_stmt *res;

   char percent = '%';
   const char *tail;

   strcpy(tempname, filename);
   /*Assumes only part1 of the file will be linked to share*/
   /*The part1 name in the share would be part1.<filename>*/
   /*All the fileparts in the database would be saved as part<number>.<filename>*/
   /*This checks if part1 of a certain file is open*/
   /*remove part1. in the filename*/
   /*ex: part1.DOTS.mkv = DOTS.mkv*/
   // remove part1 from filename
   //if (strstr(filename, "part1.") != NULL){
   //  memmove(filename, filename + strlen("part1."), 1 + strlen(filename + strlen("part1.")));
   //}

   // get the root (meron nang / sa dulo yun!!)
   rc = sqlite3_open(DBNAME, &db);
   if (rc != SQLITE_OK){
      fprintf(stderr, "File Assembly: Can't open database: %s\n", sqlite3_errmsg(db));
      sqlite3_close(db);
      exit(1);
   }
   sprintf(query, "SELECT mountpt from CacheContent WHERE filename='%s'", filename);
   rc = sqlite3_prepare_v2(db, query, 1000, &res, &tail);
   int good = 0;
   while (!good){
        rc = sqlite3_prepare_v2(db, query, 1000, &res, &tail);
        if (rc == SQLITE_BUSY){
            // db is locked?
        } else { good = 1; }
    }
    String root = "";
    if (sqlite3_step(res) == SQLITE_ROW) {
        strcpy(root, sqlite3_column_text(res,0));
    }
    sqlite3_finalize(res);

    if (strstr(filename, "part1.") != NULL){
	memmove(filename, filename+strlen("part1."), 1+strlen(filename+strlen("part1.")));
    }

   /*Look for all the fileparts in the database. part<number>.<filename>*/
   sprintf(query, "SELECT filename, fileloc FROM VolContent WHERE filename LIKE '%spart%c.%s'", root, percent, filename);
 
   rc = sqlite3_prepare_v2(db, query, 1000, &res, &tail);
   good = 0;
   while (!good) {
        rc = sqlite3_prepare_v2(db, query, 1000, &res, &tail);
        if (rc == SQLITE_BUSY){
            // db is locked?
        } else { good = 1; }
    }

    String files = "";
    String assfile = "";
    String volname = "";   // for moving to store
    while (sqlite3_step(res) == SQLITE_ROW){
        if (strstr(sqlite3_column_text(res,0), "part1.") != NULL){
        //if file contains part1
            strcpy(assfile, sqlite3_column_text(res,0)); //will be the filename
            sprintf(volname, "%s/%s", sqlite3_column_text(res,1), sqlite3_column_text(res,0));
        }

        String name = "";
        sprintf(name, "\"%s/%s\"", sqlite3_column_text(res,1), sqlite3_column_text(res,0));
        strcat(files, name);
        strcat(files, " ");
    }
    sqlite3_finalize(res);

   sprintf(comm, "cat %s > '%s/part1.%s'", files, ASSEMBLY_LOC, filename);
   system(comm);
   syslog(LOG_INFO, "VolumeManagement: Assembled File: %s/%s\n", ASSEMBLY_LOC, assfile);
   // put orig file in store
   String mv = "", cp = "";
   //copy original part1 of file to CVFStore folder
   sprintf(cp, "cp '%s' '%s/%s'", volname, STORAGE_LOC, tempname);
   //move assembled file from assembly to volume with part1
   sprintf(mv, "mv '%s/part1.%s' '%s'", ASSEMBLY_LOC, filename, volname);
   system(cp);
   system(mv);

   printf("[+] %s: %s\n", STORAGE_LOC, tempname);

   FILE *fp1 = fopen("../file_transaction/assembled.txt", "a");
   fprintf(fp1, "%s\n", tempname);
   fclose(fp1);
   sqlite3_close(db);
}
/*
 * This ist the Entry Function of this Mex-DLL
 */
void mexFunction(int nlhs, mxArray*plhs[], int nrhs, const mxArray*prhs[])
{
    mexAtExit(CloseDBs);
    
    /*
     * Get the current Language
     */
    if (Language == -1)
    {
#ifdef _WIN32        
        switch(PRIMARYLANGID(GetUserDefaultLangID()))
        {
            case LANG_GERMAN:
                Language = 1;
                break;
                
            default:
                Language = 0;
        }
#else
        Language = 0;
#endif
    }
    
	/*
	 * Print Version Information
	 */
	if (! FirstStart)
    {
    	FirstStart = true;

        mexPrintf (MSG_HELLO, sqlite3_libversion());
    }
    
    int db_id = 0;
    int CommandPos = 0;
    int NumArgs = nrhs;
    int i;
    
    /*
     * Check if the first argument is a number, then we have to use
	 * this number as an database id.
     */
    if (nrhs >= 1 && mxIsNumeric(prhs[0]))
    {
        db_id = getinteger(prhs[0]);
        if (db_id < 0 || db_id > MaxNumOfDbs)
        {
            mexPrintf(MSG_INVALIDDBHANDLE);
            mexErrMsgTxt(MSG_IMPOSSIBLE);
        }
        db_id --;
        CommandPos ++;
        NumArgs --;
    }

    /*
     * no argument -> fail
     */
    if (NumArgs < 1)
    {
        mexPrintf(MSG_USAGE);
        mexErrMsgTxt(MSG_INVALIDARG);
    }
    
    /*
     * The next (or first if no db number available) is the command,
     * it has to be a string.
     * This fails also, if the first arg is a db-id and there is no 
     * further argument
     */
    if (! mxIsChar(prhs[CommandPos]))
    {
        mexPrintf(MSG_USAGE);
        mexErrMsgTxt(MSG_INVALIDARG);
    }
    
	/*
	 * Get the command string
	 */
    char *command = getstring(prhs[CommandPos]);
    
    /*
     * Adjust the Argument pointer and counter
     */
    int FirstArg = CommandPos +1;
    NumArgs --;
    
    if (! strcmp(command, "open"))
    {
		/*
		 * open a database. There has to be one string argument,
		 * the database filename
		 */
        if (NumArgs != 1 || !mxIsChar(prhs[FirstArg]))
        {
            mexPrintf(MSG_NOOPENARG, mexFunctionName());
			mxFree(command);
            mexErrMsgTxt(MSG_INVALIDARG);
        }
        
		// TODO: possible Memoryleak 'command not freed' when getstring fails
        char* dbname = getstring(prhs[FirstArg]);

		/*
		 * Is there an database ID? The close the database with the same id 
		 */
        if (db_id > 0 && g_dbs[db_id])
        {
            sqlite3_close(g_dbs[db_id]);
            g_dbs[db_id] = 0;
        }

		/*
		 * If there isn't an database id, then try to get one
		 */
        if (db_id < 0)
        {
            for (i = 0; i < MaxNumOfDbs; i++)
            {
                if (g_dbs[i] == 0)
                {
                    db_id = i;
                    break;
                }
            }
        }
		/*
		 * no database id? sorry, database id table full
		 */
        if (db_id < 0)
        {
            plhs[0] = mxCreateDoubleScalar((double) 0);
            mexPrintf(MSG_NOFREESLOT);
			mxFree(command);
        	mxFree(dbname);
            mexErrMsgTxt(MSG_IMPOSSIBLE);
        }
       
		/*
		 * Open the database
		 */
        int rc = sqlite3_open(dbname, &g_dbs[db_id]);
        
        if (rc)
        {
			/*
			 * Anything wrong? free the database id and inform the user
			 */
            mexPrintf(MSG_CANTOPEN, sqlite3_errmsg(g_dbs[db_id]));
            sqlite3_close(g_dbs[db_id]);

            g_dbs[db_id] = 0;
            plhs[0] = mxCreateDoubleScalar((double) 0);
            
			mxFree(command);
	        mxFree(dbname);
            mexErrMsgTxt(MSG_IMPOSSIBLE);
        }
        
        /*
         * Set Default Busytimeout
         */
        rc = sqlite3_busy_timeout(g_dbs[db_id], DEFAULT_BUSYTIMEOUT);
        if (rc)
        {
			/*
			 * Anything wrong? free the database id and inform the user
			 */
            mexPrintf(MSG_CANTOPEN, sqlite3_errmsg(g_dbs[db_id]));
            sqlite3_close(g_dbs[db_id]);

            g_dbs[db_id] = 0;
            plhs[0] = mxCreateDoubleScalar((double) 0);
            
			mxFree(command);
	        mxFree(dbname);
            mexErrMsgTxt(MSG_BUSYTIMEOUTFAIL);
        }
        
		/*
		 * return value will be the used database id
		 */
        plhs[0] = mxCreateDoubleScalar((double) db_id +1);
        mxFree(dbname);
    }
    else if (! strcmp(command, "close"))
    {
		/*
		 * close a database
		 */

        /*
         * There should be no Argument to close
         */
        if (NumArgs > 0)
        {
			mxFree(command);
            mexErrMsgTxt(MSG_INVALIDARG);
        }
        
		/*
		 * if the database id is < 0 than close all open databases
		 */
        if (db_id < 0)
        {
            for (i = 0; i < MaxNumOfDbs; i++)
            {
                if (g_dbs[i])
                {
                    sqlite3_close(g_dbs[i]);
                    g_dbs[i] = 0;
                }
            }
        }
        else
        {
			/*
			 * If the database is open, then close it. Otherwise
			 * inform the user
			 */
            if (! g_dbs[db_id])
            {
				mxFree(command);
                mexErrMsgTxt(MSG_DBNOTOPEN);
            }
            else
            {
                sqlite3_close(g_dbs[db_id]);
                g_dbs[db_id] = 0;
            }
        }
    }
    else if (! strcmp(command, "status"))
    {
        /*
         * There should be no Argument to status
         */
        if (NumArgs > 0)
        {
			mxFree(command);
            mexErrMsgTxt(MSG_INVALIDARG);
        }
        
    	for (i = 0; i < MaxNumOfDbs; i++)
        {
            mexPrintf("DB Handle %d: %s\n", i, g_dbs[i] ? "OPEN" : "CLOSED");
        }
    }
    else if (! _strcmpi(command, "setbusytimeout"))
    {
        /*
         * There should be one Argument, the Timeout in ms
         */
        if (NumArgs != 1 || !mxIsNumeric(prhs[FirstArg]))
        {
			mxFree(command);
            mexErrMsgTxt(MSG_INVALIDARG);
        }

        if (! g_dbs[db_id])
        {
            mxFree(command);
            mexErrMsgTxt(MSG_DBNOTOPEN);
        }
        else
        {
            /*
             * Set Busytimeout
             */
            int TimeoutValue = getinteger(prhs[FirstArg]);
    
            int rc = sqlite3_busy_timeout(g_dbs[db_id], TimeoutValue);
            if (rc)
            {
                /*
                 * Anything wrong? free the database id and inform the user
                 */
                mexPrintf(MSG_CANTOPEN, sqlite3_errmsg(g_dbs[db_id]));
                sqlite3_close(g_dbs[db_id]);

                g_dbs[db_id] = 0;
                plhs[0] = mxCreateDoubleScalar((double) 0);

                mxFree(command);
                mexErrMsgTxt(MSG_BUSYTIMEOUTFAIL);
            }
        }
    }
    else
    {
		/*
		 * database id < 0? Thats an error...
		 */
        if (db_id < 0)
        {
            mexPrintf(MSG_INVALIDDBHANDLE);
			mxFree(command);
            mexErrMsgTxt(MSG_IMPOSSIBLE);
        }
        
		/*
		 * database not open? -> error
		 */
        if (!g_dbs[db_id])
        {
			mxFree(command);
            mexErrMsgTxt(MSG_DBNOTOPEN);
        }
        
		/*
		 * Every unknown command is treated as an sql query string
		 */
		const char* query = command;

        /*
         * a query shuld have no arguments
         */
        if (NumArgs > 0)
        {
			mxFree(command);
            mexErrMsgTxt(MSG_INVALIDARG);
        }
        
		/*
		 * emulate the "show tables" sql query
		 */
        if (! _strcmpi(query, "show tables"))
        {
            query = "SELECT name as tablename FROM sqlite_master "
                    "WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' "
                    "UNION ALL "
                    "SELECT name as tablename FROM sqlite_temp_master "
                    "WHERE type IN ('table','view') "
                    "ORDER BY 1";
        }

		/*
		 * complete the query
		 */
        if (sqlite3_complete(query))
        {
			mxFree(command);
            mexErrMsgTxt(MSG_INVQUERY);
        }
        
        sqlite3_stmt *st;
        
		/*
		 * and prepare it
		 * if anything is wrong with the query, than complain about it.
		 */
        if (sqlite3_prepare_v2(g_dbs[db_id], query, -1, &st, 0))
        {
            if (st)
                sqlite3_finalize(st);
            
			mxFree(command);
            mexErrMsgIdAndTxt(TransErrToIdent(g_dbs[db_id]), sqlite3_errmsg(g_dbs[db_id]));
        }

		/*
		 * Any results?
		 */
        int ncol = sqlite3_column_count(st);
        if (ncol > 0)
        {
            char **fieldnames = new char *[ncol];   /* Column names */
            Values* allrows = 0;                    /* All query results */
            Values* lastrow = 0;					/* pointer to the last result row */
            int rowcount = 0;						/* number of result rows */
            
			/*
			 * Get the column names of the result set
			 */
            for(i=0; i<ncol; i++)
            {
                const char *cname = sqlite3_column_name(st, i);
                
                fieldnames[i] = new char [strlen(cname) +1];
                strcpy (fieldnames[i], cname);
				/*
				 * replace invalid chars by '_', so we can build
				 * valid MATLAB structs
				 */
                char *mk_c = fieldnames[i];
                while (*mk_c)
                {
                	if ((*mk_c == ' ') || (*mk_c == '*') || (*mk_c == '?'))
                    	*mk_c = '_';
                    mk_c++;
                }
            }
            
            /*
			 * get the result rows from the engine
			 *
			 * We cannot get the number of result lines, so we must
			 * read them in a loop and save them into an temporary list.
			 * Later, we can transfer this List into an MATLAB array of structs.
			 * This way, we must allocate enough memory for two result sets,
			 * but we save time by allocating the MATLAB Array at once.
			 */
            for(;;)
            {
				/*
				 * Advance to teh next row
				 */
                int step_res = sqlite3_step(st);

				/*
				 * no row left? break out of the loop
				 */
                if (step_res != SQLITE_ROW)
                    break;

				/*
				 * get new memory for the result
				 */
                Values* RecordValues = new Values(ncol);
                
                Value *v = RecordValues->m_Values;
                for (int j = 0; j < ncol; j++, v++)
                {
                     int fieldtype = sqlite3_column_type(st,j);

                     v->m_Type = fieldtype;
                     v->m_Size = 0;
                     
                     switch (fieldtype)
                     {
                         case SQLITE_NULL:      v->m_NumericValue = g_NaN;                                   break;
                         case SQLITE_INTEGER:	v->m_NumericValue = (double) sqlite3_column_int(st, j);      break;
                         case SQLITE_FLOAT:     v->m_NumericValue = (double) sqlite3_column_double(st, j);	 break;
                         case SQLITE_TEXT:      v->m_StringValue  = strnewdup((const char*) sqlite3_column_text(st, j));   break;
                         case SQLITE_BLOB:      
                            {
                                v->m_Size = sqlite3_column_bytes(st,j);
                                if (v->m_Size > 0)
                                {
                                    v->m_StringValue = new char[v->m_Size];
                                    memcpy(v->m_StringValue, sqlite3_column_blob(st,j), v->m_Size);
                                }
                                else
                                {
                                    v->m_Size = 0;
                                }
                            }
                            break;
                         default:	
							mxFree(command);
							mexErrMsgTxt(MSG_UNKNWNDBTYPE);
                     }
                }
				/*
				 * and add this row to the list of all result rows
				 */
                if (! lastrow)
                {
                    allrows = lastrow = RecordValues;
                }
                else
                {
                    lastrow->m_NextValues = RecordValues;
                    lastrow = lastrow->m_NextValues;
                }
				/*
				 * we have one more...
				 */
                rowcount ++;
            }
            
			/*
			 * end the sql engine
			 */
            sqlite3_finalize(st);

			/*
			 * got nothing? return an empty result to MATLAB
			 */
            if (rowcount == 0 || ! allrows)
            {
                if (!( plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL) ))
				{
					mxFree(command);
                    mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
				}
            }
            else
            {
				/*
				 * Allocate an array of MATLAB structs to return as result
				 */
                int ndims[2];
                
                ndims[0] = rowcount;
                ndims[1] = 1;
                
                if (( plhs[0] = mxCreateStructArray (2, ndims, ncol, (const char**)fieldnames)) == 0)
                {
					mxFree(command);
                    mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
                }
                
				/*
				 * transfer the result rows from the temporary list into the result array
				 */
                lastrow = allrows;
                i = 0;
                while(lastrow)
                {
                    Value* recordvalue = lastrow->m_Values;
                    
                    for (int j = 0; j < ncol; j++, recordvalue++)
                    {
                        if (recordvalue -> m_Type == SQLITE_TEXT)
                        {
                            mxArray* c = mxCreateString(recordvalue->m_StringValue);
                            mxSetFieldByNumber(plhs[0], i, j, c);
                        }
                        else if (recordvalue -> m_Type == SQLITE_NULL && !NULLasNaN)
                        {
                            mxArray* out_double = mxCreateDoubleMatrix(0,0,mxREAL);
                            mxSetFieldByNumber(plhs[0], i, j, out_double);
                        }
                        else if (recordvalue -> m_Type == SQLITE_BLOB)
                        {
                            if (recordvalue->m_Size > 0)
                            {
                                int BytePos;
                                int NumDims[2]={1,1};
                                NumDims[1]=recordvalue->m_Size;
                                mxArray*out_uchar8=mxCreateNumericArray(2, NumDims, mxUINT8_CLASS, mxREAL);
                                unsigned char *v = (unsigned char *) mxGetData(out_uchar8);
                                
                                memcpy(v, recordvalue->m_StringValue, recordvalue->m_Size);
                                    
                                mxSetFieldByNumber(plhs[0], i, j, out_uchar8);
                            }
                            else
                            {
                                // empty BLOB
                                mxArray* out_double = mxCreateDoubleMatrix(0,0,mxREAL);
                                mxSetFieldByNumber(plhs[0], i, j, out_double);
                            }
                        }
                        else
                        {
                            mxArray* out_double = mxCreateDoubleScalar(recordvalue->m_NumericValue);
                            mxSetFieldByNumber(plhs[0], i, j, out_double);
                        }
                    }
                    allrows = lastrow;
                    lastrow = lastrow->m_NextValues;
                    delete allrows;
                    i++;
                }
            }
            for(int i=0; i<ncol; i++)
                delete [] fieldnames[i];
            delete [] fieldnames;
        }
        else
        {
			/*
			 * no result, cleanup the sqlite engine
			 */
            int res = sqlite3_step(st);
            sqlite3_finalize(st);

			if (!( plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL) )) 
			{
                mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
            }

            if (res != SQLITE_DONE)
            {
				mxFree(command);
                mexErrMsgIdAndTxt(TransErrToIdent(g_dbs[db_id]), sqlite3_errmsg(g_dbs[db_id]));
            }            
        }
    }
	mxFree(command);
}
// Open a connection to a valid SoftHSM v1 database
sqlite3* openDB(char* dbPath)
{
	int result;
	sqlite3* db = NULL;
	sqlite3_stmt* pragStatem = NULL;
	int dbVersion;

	// Open the database
	result = sqlite3_open(dbPath, &db);
	if (result)
	{
		fprintf(stderr, "ERROR: Could not open token database. "
				"Probably wrong path or privileges: %s\n", dbPath);
		return NULL;
	}

	// Check the schema version
	if (sqlite3_prepare_v2(db, "PRAGMA user_version;", -1, &pragStatem, NULL))
	{
		fprintf(stderr, "ERROR: Could not prepare a SQL statement\n");
		sqlite3_close(db);
		return NULL;
	}
	if (sqlite3_step(pragStatem) == SQLITE_ROW)
	{
		dbVersion = sqlite3_column_int(pragStatem, 0);
		sqlite3_finalize(pragStatem);

		if (dbVersion != 100)
		{
			fprintf(stderr, "ERROR: Wrong database schema version: %s\n", dbPath);
			sqlite3_close(db);
			return NULL;
		}
	}
	else
	{
		fprintf(stderr, "ERROR: The token database has not been initialized by SoftHSM\n");
		sqlite3_finalize(pragStatem);
		sqlite3_close(db);
		return NULL;
	}

	// Check that the Token table exist
	result = sqlite3_exec(db, "SELECT COUNT(variableID) FROM Token;", NULL, NULL, NULL);
	if (result)
	{
		fprintf(stderr, "ERROR: The Token table is missing the in database\n");
		sqlite3_close(db);
		return NULL;
	}

	// Check that the Objects table exist
	result = sqlite3_exec(db, "SELECT COUNT(objectID) FROM Objects;", NULL, NULL, NULL);
	if (result)
	{
		fprintf(stderr, "ERROR: The Objects table is missing the in database\n");
		sqlite3_close(db);
		return NULL;
	}

	// Check that the Attributes table exist
	result = sqlite3_exec(db, "SELECT COUNT(attributeID) FROM Attributes;", NULL, NULL, NULL);
	if (result)
	{
		fprintf(stderr, "ERROR: The Attributes table is missing in the database\n");
		sqlite3_close(db);
		return NULL;
	}

	return db;
}
Example #20
0
// Main function, the base TCP server
int main(int argc, char *argv[])
{
	//-------------------- SET UP VARIABLES -----------------------
	
	// Set up all required variables for sockets programming, starting with addrinfo "hints" struct and pointers to results list
	struct addrinfo hints, *result;

	// Integer variable used to set socket options
	int yes = 1;

	// Create command buffer, to send commands directly to the server
	char command[512] = { '\0' };

	// Define a generic indexer variable for loops
	int i = 0;

	// Set up SQLite statement struct
	sqlite3_stmt *stmt;

	// Create a buffer to store queries to process on the database
	char query[256] = { '\0' };

	//------------------ INITIALIZE SIGNAL HANDLERS ---------------

	// Install signal handlers for graceful shutdown
	// Install SIGHUP signal handler
	signal(SIGHUP, shutdown_handler);

	// Install SIGINT signal handler
	signal(SIGINT, shutdown_handler);

	// Install SIGTERM signal handler
	signal(SIGTERM, shutdown_handler);

	// Install signal handlers for statistics output
	// Install SIGUSR1 signal handler
	signal(SIGUSR1, stat_handler);

	// Install SIGUSR2 signal handler
	signal(SIGUSR2, stat_handler);

	//------------------ BEGIN SERVER INITIALIZATION --------------

	// Read in terminal on which server was started
	term = strdup(ttyname(1));

	// Print initialization message
	fprintf(stdout, "%s: %s %s - Justin Hill, Gordon Keesler, Matt Layher (CS5550 Spring 2012)\n", SERVER_NAME, INFO_MSG, SERVER_NAME);

	// Capture initial start time
	start_time = time(NULL);

	//------------------ PARSE COMMAND LINE ARGUMENTS -------------

	// Iterate through all argv command line arguments, parsing out necessary flags
	for(i = 1; i < argc; i++)
	{
		// '-d' or '--daemon' flag: daemonize the server, and run it in the background
		if(strcmp("-d", argv[i]) == 0 || strcmp("--daemon", argv[i]) == 0)
		{
			// Set daemon flag to true, so we may daemonize later
			daemonized = 1;
		}
		// '-h' or '--help' flag: print help and usage for this server, then exit
		else if(strcmp("-h", argv[i]) == 0 || strcmp("--help", argv[i]) == 0)
		{
			// Print usage message
			fprintf(stdout, "usage: %s [-d | --daemon] [-h | --help] [-l | --lock lock_file] [-p | --port port] [-q | --queue queue_length] [-t | --threads thread_count]\n\n", SERVER_NAME);

			// Print out all available flags
			fprintf(stdout, "%s flags:\n", SERVER_NAME);
			fprintf(stdout, "\t-d | --daemon:     daemonize - start server as a daemon, running it in the background\n");
			fprintf(stdout, "\t-h | --help:            help - print usage information and details about each flag the server accepts\n");
			fprintf(stdout, "\t-l | --lock:       lock_file - specify the location of the lock file utilized when the server is daemonized (default: %s)\n", LOCKFILE);
			fprintf(stdout, "\t-p | --port:            port - specify an alternative port number to run the server (default: %s)\n", DEFAULT_PORT);
			fprintf(stdout, "\t-q | --queue:   queue_length - specify the connection queue length for the incoming socket (default: %d)\n", QUEUE_LENGTH);
			fprintf(stdout, "\t-t | --threads: thread_count - specify the number of threads to generate (max number of clients) (default: %d)\n", NUM_THREADS);
			fprintf(stdout, "\n");

			// Print out all available console commands via the common console_help() function
			console_help();

			// Exit the server
			exit(0);
		}
		// '-l' or '--lock' flag: specify an alternate lock file location
		else if(strcmp("-l", argv[i]) == 0 || strcmp("--lock", argv[i]) == 0)
		{
			// Make sure that another argument exists, specifying the lockfile location
			if(argv[i+1] != NULL)
			{
				// Set lock file location as specified on the command line
				lock_location = argv[i+1];
				i++;
			}
			else
			{
				// Print error and use default location if no lockfile was specified after the flag
				fprintf(stderr, "%s: %s no lockfile location specified, defaulting to %s\n", SERVER_NAME, ERROR_MSG, LOCKFILE);
			}
		}
		// '-p' or '--port' flag: specifies an alternative port number to run the server
		else if(strcmp("-p", argv[i]) == 0 || strcmp("--port", argv[i]) == 0)
		{
			// Make sure that another argument exists, specifying the port number
			if(argv[i+1] != NULL)
			{
				// Ensure this port is a valid integer
				if(validate_int(argv[i+1]))
				{
					// Set this port to be used if it's within the valid range, else use the default
					if(atoi(argv[i+1]) >= 0 && atoi(argv[i+1]) <= MAX_PORT)
					{
						port = argv[i+1];
						i++;
					}
					else
						fprintf(stderr, "%s: %s port lies outside valid range (0-%d), defaulting to %s\n", SERVER_NAME, ERROR_MSG, MAX_PORT, DEFAULT_PORT);
				}
				else
				{
					// Print error and use default port if an invalid port number was specified
					fprintf(stderr, "%s: %s invalid port number specified, defaulting to %s\n", SERVER_NAME, ERROR_MSG, DEFAULT_PORT);
				}
			}
			else
			{
				// Print error and use default port if no port number was specified after the flag
				fprintf(stderr, "%s: %s no port number specified after flag, defaulting to %s\n", SERVER_NAME, ERROR_MSG, DEFAULT_PORT);
			}
		}
		// '-q' or '--queue' flag: specify the connection queue length
		else if(strcmp("-q", argv[i]) == 0 || strcmp("--queue", argv[i]) == 0)
		{
			// Make sure another argument exists, specifying the queue length
			if(argv[i+1] != NULL)	
			{
				// Ensure this is a valid integer for queue length
				if(validate_int(argv[i+1]))
				{
					// Set connection queue length to the number specified on the command line, if it's a number more than 0, else use the default
					if(atoi(argv[i+1]) >= 1)
					{
						queue_length = atoi(argv[i+1]);
						i++;
					}
					else
						fprintf(stderr, "%s: %s cannot use negative or zero queue length, defaulting to length %d\n", SERVER_NAME, ERROR_MSG, QUEUE_LENGTH);
				}
				else
				{
					// Print error and use default queue length if an invalid number was specified
					fprintf(stderr, "%s: %s invalid queue length specified, defaulting to length %d\n", SERVER_NAME, ERROR_MSG, QUEUE_LENGTH);
				}
			}
			else
			{
				// Print error and use default queue length if no length was specified after the flag
				fprintf(stderr, "%s: %s no queue length specified after flag, default to length %d\n", SERVER_NAME, ERROR_MSG, QUEUE_LENGTH);
			}
		}
		// '-t' or '--threads' flag: specify the number of threads to generate in the thread pool
		else if(strcmp("-t", argv[i]) == 0 || strcmp("--threads", argv[i]) == 0)
		{
			// Make sure next argument exists, specifying the number of threads
			if(argv[i+1] != NULL)
			{
				// Ensure this number is a valid integer
				if(validate_int(argv[i+1]))
				{
					// Set number of threads to the number specified on the command line, if it's a number more than 0, else use the default
					if(atoi(argv[i+1]) >= 1)
					{
						num_threads = atoi(argv[i+1]);
						i++;
					}
					else
						fprintf(stderr, "%s: %s cannot use negative or zero threads, defaulting to %d threads\n", SERVER_NAME, ERROR_MSG, NUM_THREADS);
				}
				else
				{
					// Print error and use default number of threads if an invalid number was specified
					fprintf(stderr, "%s: %s invalid number of threads specified, defaulting to %d threads\n", SERVER_NAME, ERROR_MSG, NUM_THREADS);
				}
			}
			else
			{
				// Print error and use default number of threads if no count was specified after the flag
				fprintf(stderr, "%s: %s no thread count specified after flag, defaulting to %d threads\n", SERVER_NAME, ERROR_MSG, NUM_THREADS);
			}
		}
		else
		{
			// Else, an invalid flag or parameter was specified; print an error and exit
			fprintf(stderr, "%s: %s unknown parameter '%s' specified, please run '%s -h' for help and usage\n", SERVER_NAME, ERROR_MSG, argv[i], SERVER_NAME);
			exit(-1);
		}
	}

	//------------------------ OPEN SQLITE DATABASE ----------------

	// Open database file, as specified in config header; check for success
	sqlite3_open(DB_FILE, &db);
	if(db == NULL)
	{
		// Print an error message and quit if database fails to open
		fprintf(stderr, "%s: %s sqlite: could not open database %s\n", SERVER_NAME, ERROR_MSG, DB_FILE);
		exit(-1);
	}

	// Create a query to truncate the files table in the database
	sprintf(query, "DELETE FROM files");

	// Prepare, evaluate, and finalize SQLite query
	sqlite3_prepare_v2(db, query, strlen(query) + 1, &stmt, NULL);
	if(sqlite3_step(stmt) != SQLITE_DONE)
	{
		// On query failure, print an error and exit
		fprintf(stderr, "%s: %s sqlite: could not truncate files table\n", SERVER_NAME, ERROR_MSG);
		exit(-1);
	}
	sqlite3_finalize(stmt);

	//------------------------ INITIALIZE TCP SERVER ---------------

	// Clear the hints struct using memset to nullify it
	memset(&hints, 0, sizeof(hints));

	// Set options for hints to use IPv4, a TCP connection, and the machine's current IP address
	hints.ai_family = AF_INET;          // IPv4
	hints.ai_socktype = SOCK_STREAM;    // Reliable TCP connection
	hints.ai_flags = AI_PASSIVE;        // Use my ip address

	// now populate our result addrinfo
	if((getaddrinfo(NULL, port, &hints, &result)) != 0)
	{ 
		// If getaddrinfo() fails, print an error and quit the program, since setup cannot continue.
		fprintf(stderr, "%s: %s getaddrinfo() call failed\n", SERVER_NAME, ERROR_MSG);
		exit(-1);
	}

	// Attempt to instantiate the local socket, using values set by getaddrinfo()
	if((loc_fd = socket(result->ai_family, result->ai_socktype, result->ai_protocol)) == -1)
	{
		// On socket creation failure, print an error and exit
		fprintf(stderr, "%s: %s local socket creation failed\n", SERVER_NAME, ERROR_MSG);
		exit(-1);
	}

	// Allow the system to free and re-bind the socket if it is already in use
	if(setsockopt(loc_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
	{
		// If setting a socket option fails, terminate the program after printing an error
		fprintf(stderr, "%s: %s failed to set socket option: SO_REUSEADDR\n", SERVER_NAME, ERROR_MSG);
		exit(-1);
	}

	// Attempt to bind the local socket
	if((bind(loc_fd, result->ai_addr, result->ai_addrlen)) == -1)
	{
		// If socket binding fails, it's typically one of two scenarios:
		// 1) Check if socket is on a privileged port, and permission is denied
		if(atoi(port) < PRIVILEGED_PORT)
			fprintf(stderr, "%s: %s failed to bind local socket (permission denied?)\n", SERVER_NAME, ERROR_MSG);
		// 2) Else, the socket is probably already bound
		else
			fprintf(stderr, "%s: %s failed to bind local socket (socket already in use?)\n", SERVER_NAME, ERROR_MSG);

		// Exit on failure
		exit(-1);
	}
	
	// Free the results struct, as it is no longer needed
	freeaddrinfo(result);

	// Begin listening on the local socket, and set connection queue length as defined above
	if((listen(loc_fd, queue_length)) == -1)
	{
		// Print error message if socket fails to begin listening
		fprintf(stderr, "%s: %s failed to begin listening on local socket\n", SERVER_NAME, ERROR_MSG);
	}
    
	//-------------------------- DAEMONIZATION ------------------

	// If server is being daemonized, do so now.
	if(daemonized == 1)
		daemonize();
	else
	{	
		// Initialize a thread pool, using number of threads as defined earlier
		threadpool = thpool_init(num_threads);

		// Initialize the network thread to handle all incoming connections
		pthread_create(&net_thread, NULL, &tcp_listen, NULL);
	
		// Print out server information and ready message
		fprintf(stdout, "%s: %s server initialized [PID: %d] [port: %s] [queue: %d] [threads: %d]\n", SERVER_NAME, OK_MSG, getpid(), port, queue_length, num_threads);

		// If server is not being daemonized, use the default console interface
		fprintf(stdout, "%s: %s type 'stop' or hit Ctrl+C (SIGINT) to stop server\n", SERVER_NAME, INFO_MSG);
	}

	//------------------------- CONSOLE COMMAND ---------------

	// Loop continuously until 'stop' is provided on the console
	while(1)
	{
		// Read in user input, clean it up
		fgets(command, sizeof(command), stdin);
		clean_string((char *)&command);

		// 'clear' - Clear the console
		if(strcmp(command, "clear") == 0)
			system("clear");
		// 'help' - Display the common console help menu
		else if(strcmp(command, "help") == 0)
			console_help();
		// 'stat' - Print out server statistics
		else if(strcmp(command, "stat") == 0)
			print_stats();
		// 'stop' - Stop the server, breaking this loop
		else if(strcmp(command, "stop") == 0)
			break;
		// Else, print console error stating command does not exist
		else
			fprintf(stderr, "%s: %s unknown console command '%s', type 'help' for console command help\n", SERVER_NAME, ERROR_MSG, command);
	}

	// Send SIGINT to the server so that it will gracefully terminate via signal handler
	kill(getpid(), SIGINT);
}
Example #21
0
File: pkgdb.c Project: flz/pkgng
int
pkgdb_open(struct pkgdb **db, pkgdb_t remote, int mode)
{
	int retcode;
	struct stat st;
	char *errmsg;
	char localpath[MAXPATHLEN];
	char remotepath[MAXPATHLEN];
	char sql[BUFSIZ];
	const char *dbdir;

	/* First check to make sure PKG_DBDIR exists before trying to use it */
	dbdir = pkg_config("PKG_DBDIR");
	if (eaccess(dbdir, mode) == -1)
		return (pkg_error_set(EPKG_FATAL, "Package database directory "
		    "%s error: %s", dbdir, strerror(errno)));

	snprintf(localpath, sizeof(localpath), "%s/local.sqlite", dbdir);

	if ((*db = calloc(1, sizeof(struct pkgdb))) == NULL)
		return (pkg_error_set(EPKG_FATAL, "calloc(): %s", strerror(errno)));

	(*db)->remote = remote;

	retcode = stat(localpath, &st);
	if (retcode == -1 && errno != ENOENT)
		return (pkg_error_set(EPKG_FATAL, "can not stat %s: %s", localpath,
							  strerror(errno)));

	if (remote == PKGDB_REMOTE) {
		snprintf(remotepath, sizeof(localpath), "%s/repo.sqlite", dbdir);
		retcode = stat(remotepath, &st);
		if (retcode == -1 && errno != ENOENT)
			return (pkg_error_set(EPKG_FATAL, "can not stat %s: %s", remotepath,
						strerror(errno)));
	}

	if (sqlite3_open(localpath, &(*db)->sqlite) != SQLITE_OK)
		return (ERROR_SQLITE((*db)->sqlite));

	if (remote == PKGDB_REMOTE) {
		sqlite3_snprintf(BUFSIZ, sql, "ATTACH \"%s\" as remote;", remotepath);

		if (sqlite3_exec((*db)->sqlite, sql, NULL, NULL, &errmsg) != SQLITE_OK){
			sqlite3_free(errmsg);
			return ERROR_SQLITE((*db)->sqlite);
		}
	}

	/* If the database is missing we have to initialize it */
	if (retcode == -1)
		if ((retcode = pkgdb_init((*db)->sqlite)) != EPKG_OK)
			return (ERROR_SQLITE((*db)->sqlite));

	sqlite3_create_function((*db)->sqlite, "regexp", 2, SQLITE_ANY, NULL,
							pkgdb_regex_basic, NULL, NULL);
	sqlite3_create_function((*db)->sqlite, "eregexp", 2, SQLITE_ANY, NULL,
							pkgdb_regex_extended, NULL, NULL);
	sqlite3_create_function((*db)->sqlite, "pkglt", 2, SQLITE_ANY, NULL,
			pkgdb_pkglt, NULL, NULL);
	sqlite3_create_function((*db)->sqlite, "pkggt", 2, SQLITE_ANY, NULL,
			pkgdb_pkggt, NULL, NULL);

	/*
	 * allow forign key option which will allow to have clean support for
	 * reinstalling
	 */
	if (sqlite3_exec((*db)->sqlite, "PRAGMA foreign_keys = ON;", NULL, NULL,
		&errmsg) != SQLITE_OK) {
		pkg_error_set(EPKG_FATAL, "sqlite: %s", errmsg);
		sqlite3_free(errmsg);
		return (EPKG_FATAL);
	}

	return (EPKG_OK);
}
Example #22
0
void Lite3Connector::open(char* databaseName)
{
  int rc = sqlite3_open(databaseName, &conn);
  if (rc != SQLITE_OK)
    throw Lite3Exception(rc, "Database open failed", LITE3_MARK);
}
Example #23
0
//------------------------------------------------------------------------------
DWORD WINAPI Scan_chrome_history(LPVOID lParam)
{
  FORMAT_CALBAK_READ_INFO data;

  //get child
  HTREEITEM hitem = NULL;
  if (!CONSOL_ONLY)hitem = (HTREEITEM)SendMessage(htrv_files, TVM_GETNEXTITEM,(WPARAM)TVGN_CHILD, (LPARAM)TRV_HTREEITEM_CONF[FILES_TITLE_APPLI]);
  if ((hitem == NULL && LOCAL_SCAN) || CONSOL_ONLY)
  {
    //get path of all profils users
    //HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList
    HKEY CleTmp   = 0;
    if (RegOpenKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\",&CleTmp)==ERROR_SUCCESS)
    {
      DWORD i, nbSubKey=0, key_size;
      sqlite3 *db_tmp;

      char tmp_key[MAX_PATH], tmp_key_path[MAX_PATH];
      if (RegQueryInfoKey (CleTmp,0,0,0,&nbSubKey,0,0,0,0,0,0,0)==ERROR_SUCCESS)
      {
        #ifdef CMD_LINE_ONLY_NO_DB
        printf("\"file\";\"parameter\";\"date\";\"id_language_description\";\"session_id\";\"data\";\r\n");
        #endif

        //get subkey
        for(i=0;i<nbSubKey;i++)
        {
          key_size    = MAX_PATH;
          tmp_key[0]  = 0;
          if (RegEnumKeyEx (CleTmp,i,tmp_key,&key_size,0,0,0,0)==ERROR_SUCCESS)
          {
            //generate the key path
            snprintf(tmp_key_path,MAX_PATH,"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\%s\\",tmp_key);
            //get profil path
            if (ReadValue(HKEY_LOCAL_MACHINE,tmp_key_path,"ProfileImagePath",tmp_key, MAX_PATH))
            {
              //verify the path if %systemdrive%
              ReplaceEnv("SYSTEMDRIVE",tmp_key,MAX_PATH);


              //search file in this path
              snprintf(tmp_key_path,MAX_PATH,"%s\\Local Settings\\Application Data\\Google\\Chrome\\User Data\\Default\\*.*",tmp_key);
              WIN32_FIND_DATA wfd;
              HANDLE hfic = FindFirstFile(tmp_key_path, &wfd);
              if (hfic != INVALID_HANDLE_VALUE)
              {
                do
                {
                  if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){}else
                  {
                    if(wfd.cFileName[0] == '.' && (wfd.cFileName[1] == 0 || wfd.cFileName[1] == '.')){}
                    else
                    {
                      //test all files
                      snprintf(tmp_file_chrome,MAX_PATH,"%s\\Local Settings\\Application Data\\Google\\Chrome\\User Data\\Default\\%s",tmp_key,wfd.cFileName);

                      //test to open file
                      if (sqlite3_open(tmp_file_chrome, &db_tmp) == SQLITE_OK)
                      {
                        for (data.type =0;data.type <nb_sql_CHROME && start_scan;data.type = data.type+1)
                        {
                          if(!SQLITE_FULL_SPEED)sqlite3_exec(db_scan,"BEGIN TRANSACTION;", NULL, NULL, NULL);
                          sqlite3_exec(db_tmp, sql_CHROME[data.type].sql, callback_sqlite_chrome, &data, NULL);
                          if(!SQLITE_FULL_SPEED)sqlite3_exec(db_scan,"END TRANSACTION;", NULL, NULL, NULL);
                        }
                        sqlite3_close(db_tmp);
                      }
                    }
                  }
                }while(FindNextFile (hfic,&wfd));
              }
            }
          }
        }
      }
      RegCloseKey(CleTmp);
    }
  }else
  {
    sqlite3 *db_tmp;
    #ifdef CMD_LINE_ONLY_NO_DB
    printf("\"Chrome\";\"file\";\"parameter\";\"date\";\"id_language_description\";\"session_id\";\"data\";\r\n");
    #endif
    while(hitem!=NULL)
    {
      //get item txt
      GetTextFromTrv(hitem, tmp_file_chrome, MAX_PATH);
      //test to open file
      if (sqlite3_open(tmp_file_chrome, &db_tmp) == SQLITE_OK)
      {
        for (data.type =0;data.type <nb_sql_CHROME && start_scan;data.type = data.type+1)
        {
          if(!SQLITE_FULL_SPEED)sqlite3_exec(db_scan,"BEGIN TRANSACTION;", NULL, NULL, NULL);
          sqlite3_exec(db_tmp, sql_CHROME[data.type].sql, callback_sqlite_chrome, &data, NULL);
          if(!SQLITE_FULL_SPEED)sqlite3_exec(db_scan,"END TRANSACTION;", NULL, NULL, NULL);
        }
        sqlite3_close(db_tmp);
      }
      hitem = (HTREEITEM)SendMessage(htrv_files, TVM_GETNEXTITEM,(WPARAM)TVGN_NEXT, (LPARAM)hitem);
    }
  }

  if (!CONSOL_ONLY)check_treeview(htrv_test, H_tests[(unsigned int)lParam], TRV_STATE_UNCHECK);//db_scan
  h_thread_test[(unsigned int)lParam] = 0;
  return 0;
}
Example #24
0
void initialize() {

    system("clear");


    String ip = "", netmask = "", command = "", alltargetsStr = "", currtarget = "", iqn = "", sendtargets = "", sql = "";
    String disklist = "", assocvol = "", mountpt = "", avspace = "", command1 = "", sql1 = "";


    int counter = 1;
    //sqlite3 information
    sqlite3 *db;
    int rc = 0;

    //open sqlite3 db
    rc = sqlite3_open(DBNAME,&db);
    if (rc){
       printf("\nCannot open database.\n");
       exit(0);
    }

    // get network information of initiator
    // what if interface is not eth0? what if eth1...?
    runCommand("ip addr show eth0 | grep \'inet \' | awk \'{print $2}\' | cut -f1 -d\'/\'", ip);
    runCommand("ip addr show eth0 | grep \'inet \' | awk \'{print $2}\' | cut -f2 -d\'/\'", netmask);
    // printf("*****  Network information  *****\n");
    ip[strlen(ip)] = '\0';
    netmask[strlen(netmask)] = '\0';
    syslog(LOG_INFO, "DiskPooling: Initiator IP address: %s/%s\n\n", ip, netmask);


    // do nmap for active hosts with port 3260 open
    // syslog(LOG_INFO, "DiskPooling: Scanning network...\n");
    sprintf(command, "nmap -v -n %s%s%s -p 3260 | grep open | awk '/Discovered/ {print $NF}'", ip, "/", netmask);
    runCommand(command, alltargetsStr);

    // discover iscsi targets on hosts scanned successfully
    char *ptr;
    ptr = strtok(alltargetsStr, "\n");

    while(ptr != NULL) {
    	printf("%s is a target.\n", ptr);
    	sprintf(sendtargets,"iscsiadm -m discovery -t sendtargets -p %s | awk '{print $2}'",ptr);
    	runCommand(sendtargets,iqn);
        printf("%s\n", iqn);
        sprintf(sql,"insert into Target(tid, ipadd,iqn) values (%d, '%s','%s');",counter, ptr,iqn);

        printf("** initconf, sql = %s\n", sql);

        rc = sqlite3_exec(db,sql,0,0,0);
        if (rc != SQLITE_OK){
            printf("\nDid not insert successfully!\n");
            exit(0);
        }
        strcpy(sendtargets,"");
        strcpy(sql,"");
        strcpy(iqn, "");
        ptr = strtok(NULL, "\n");
        counter++;
    }

    printf("\n\nLogging in to targets...");
    system("iscsiadm -m node --login");
    printf("\n\nAvailable partitions written to file \"%s\"\n", AV_DISKS);
    sleep(5);
    sprintf(command, "cat /proc/partitions > '%s'", AV_DISKS);
    system(command);
    system("cat /proc/partitions");

    makeVolume(0);

    system("cat '../file_transaction/AvailableDisks.txt' | grep sd[b-z] | awk '{print $4}' > SDNAME.txt");

    FILE *fp;
    string l;

    fp = fopen("SDNAME.txt", "r");
    if (fp == NULL) {
        printf("file not found\n");
        exit(1);
    }

    while(fscanf(fp, "%s", l) != EOF) {
        printf("read: %s\n", s);
    }

    printf("closign file\n");
    fclose(fp);

    // syslog(LOG_INFO, "DiskPooling: DONE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

    // syslog(LOG_INFO, "DiskPooling: Disklist before: %s\n\n", disklist);
    //strcat(disklist, "\n");
    // syslog(LOG_INFO, "DiskPooling: PTR Before: %s\n\n", ptr1);
    // syslog(LOG_INFO, "DiskPooling: DIskList after: %s\n\n", disklist);
    counter = 1;
    while(fscanf(fp, "%s", l) != EOF) {
    //    syslog(LOG_INFO, "DiskPooling: PTR: %s\n\n", ptr1);
    //    syslog(LOG_INFO, "DiskPooling: INSIDE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
        printf("this line is read: %s\n", l);
       strcat(assocvol,"/dev/vg");
       strcat(assocvol,l);
       strcat(assocvol,"/lv");
       strcat(assocvol,l);


       strcat(mountpt,"/mnt/lv");
       strcat(mountpt,l);

       sprintf(command1,"lvdisplay %s | grep 'LV Size' | awk '{print $3,$4}'",assocvol);

       runCommand(command1,avspace);

       // edit here not sure if working (assume: avspace = "12.3 GiB")
       double space_bytes = toBytes(avspace);

       sprintf(sql1,"update Target set assocvol = '%s', mountpt = '%s', avspace = %lf where tid = %d", assocvol, mountpt, space_bytes, counter);
       printf("just checking sql1 = %s\n", sql1);
    //    syslog(LOG_INFO, "DiskPooling: SQL1 = %s\n", sql1);
       rc = sqlite3_exec(db,sql1,0,0,0);

       if (rc != SQLITE_OK){
           syslog(LOG_INFO, "DiskPooling: Error: Target is not recorded");
           exit(0);
       }

       strcpy(assocvol,"");
       strcpy(mountpt,"");
       strcpy(avspace,"");
       counter++;
    //    printf("***************\n\n\n%s\n\n\n", ptr1);
    }

    printf("\n\nInitialization finished\n");
}
Example #25
0
SWITCH_DECLARE(int) switch_core_db_open(const char *filename, switch_core_db_t **ppDb)
{
    return sqlite3_open(filename, ppDb);
}
int main(int argc, char *argv[]) {

    char *filename = NULL;
    //char *filename_suffix = NULL;
    char *inputsource = NULL;
    char *outputDB = NULL;

    //Find the last / in passed filename.
    if (strrchr(argv[1],'/') == NULL) {
        if (strcmp(argv[1],"-") == 0) {
            inputsource = "/dev/stdin";
            if (argv[2] == NULL) {
                printf("Please input a name for the movie!\n");
                return -1;
            } else {
                if (strrchr(argv[2],'/') == NULL) {
                    filename = argv[2];
                } else {
                    filename = strrchr(argv[2],'/') + 1;
                }

                if (argv[3] != NULL && argc == 4) {
                    outputDB = argv[3];
                } else {
                    outputDB = "/home/gsc/videoaudiofingerprint.db";
                }

            }
        } else {
            filename = argv[1];
            inputsource = argv[1];

            if (argv[2] != NULL && argc == 3) {
                outputDB = argv[2];
            } else {
                outputDB = "/home/gsc/videoaudiofingerprint.db";
            }
        }
    } else {
        filename = strrchr(argv[1],'/') + 1;
        inputsource = argv[1];

        if (argv[3] != NULL && argc == 4) {
            outputDB = argv[3];
        } else {
            outputDB = "/home/gsc/videoaudiofingerprint.db";
        }
    }

    printf("Filename = %s Input source = %s DB output = %s argc = %d\n",filename,inputsource,outputDB, argc);

    /*** DB initialization ***/
    int retval = 0;

    // Create a handle for database connection, create a pointer to sqlite3
    sqlite3 *handle;

    //Full array init of size 5h@60fps (a.k.a large enough)
    //TO FIX: use dynamic array?
    int *fullArray = (int*) calloc ( (1080000-1), sizeof (int));

    // Create the database. If it doesnt exist, it would be created
    // pass a pointer to the pointer to sqlite3, in short sqlite3**

    retval = sqlite3_open(outputDB,&handle);
    // If connection failed, handle returns NULL
    if(retval) {
        printf("Database connection failed\n");
        return -1;
    }

    char query1[] = "create table allmovies (allmovieskey INTEGER PRIMARY KEY,name TEXT,fps INTEGER, date INTEGER);";
    // Execute the query for creating the table
    retval = sqlite3_exec(handle,query1,0,0,0);
    char query2[] = "PRAGMA count_changes = OFF";
    retval = sqlite3_exec(handle,query2,0,0,0);
    char query3[] = "PRAGMA synchronous = OFF";
    retval = sqlite3_exec(handle,query3,0,0,0);

    //Hashluma table
    char query_hash[] = "create table hashluma (avg_range int, movies TEXT)";
    retval = sqlite3_exec(handle,query_hash,0,0,0);

    if (!retval) {
        //Populating the hash tables
        printf("Populating hashluma table\n");
        char hashquery[50];
        memset(hashquery, 0, 50);
        int i = 0;
        for(i=0; i <= 254; i++) {
            sprintf(hashquery, "insert into hashluma (avg_range) values (%d)", i);
            retval = sqlite3_exec(handle,hashquery,0,0,0);
        }
    }

    char table_query[150];
    memset(table_query, 0, 150);
    sprintf(table_query,"create table '%s' (s_end FLOAT, luma INTEGER);",filename);

    int repeated = 0;

    retval = sqlite3_exec(handle,table_query,0,0,0);
    if (retval) {
        char error [100];
        memset(error, 0, 100);
        sprintf(error,"Table for movie %s already exists! Skipping fingerprinting ... \n",filename);
        printf("%s",error);
        //Decide which is the best policy, not FP? overwrite? new file?
        repeated = 1;
        sqlite3_close(handle);
        return 0;
    }
    /*** DB init finished ***/

    printf("Analyzing video %s\n",filename);

    av_register_all();

    AVFormatContext *pFormatCtx;

    // Open video file
    if(av_open_input_file(&pFormatCtx, inputsource, NULL, 0, NULL)!=0) {
        printf("Could't open file %s\n", argv[1]);
        return -1; // Couldn't open file
    }

    // Retrieve stream information
    if(av_find_stream_info(pFormatCtx)<0) {
        printf("Could't find stream information\n");
        return -1; // Couldn't find stream information
    }

    // Dump information about file onto standard error
    dump_format(pFormatCtx, 0, filename, 0);

    int i;
    AVCodecContext *pVideoCodecCtx;
    AVCodecContext *pAudioCodecCtx;

    // Find the first video stream
    int videoStream=-1;
    int audioStream=-1;
    for(i=0; i<pFormatCtx->nb_streams; i++) {
        if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO && videoStream==-1)
            videoStream=i;

        if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_AUDIO && audioStream==-1)
            audioStream=i;

    }

    if(videoStream==-1 || audioStream==-1)
        return -1; // Didn't find both streams

    // Get a pointer to the codec context for the video stream
    pVideoCodecCtx=pFormatCtx->streams[videoStream]->codec;
    // Similar, for audio stream
    pAudioCodecCtx=pFormatCtx->streams[audioStream]->codec;

    AVCodec *pVideoCodec;
    AVCodec *pAudioCodec;

    // Find the decoder for the streams
    pVideoCodec=avcodec_find_decoder(pVideoCodecCtx->codec_id);
    pAudioCodec=avcodec_find_decoder(pAudioCodecCtx->codec_id);
    if(pVideoCodec==NULL) {
        fprintf(stderr, "Unsupported video codec!\n");
        sqlite3_close(handle);
        return -1; // Codec not found
    }
    if(pAudioCodec==NULL) {
        fprintf(stderr, "Unsupported audio codec!\n");
        sqlite3_close(handle);
        return -1; // Codec not found
    }

    // Open codecs
    if(avcodec_open(pVideoCodecCtx, pVideoCodec)<0) {
        sqlite3_close(handle);
        return -1; // Could not open codec
    }
    if(avcodec_open(pAudioCodecCtx, pAudioCodec)<0) {
        sqlite3_close(handle);
        return -1; // Could not open codec
    }

    AVFrame *pVideoFrame;
    AVFrame *pVideoFrameYUV;
    AVFrame *pAudioFrame;

    int samples = 0;

    // Allocate audio/video frame
    pVideoFrame=avcodec_alloc_frame();
    pVideoFrameYUV=avcodec_alloc_frame();
    pAudioFrame=avcodec_alloc_frame();

    if(pVideoFrameYUV==NULL || pVideoFrame==NULL || pAudioFrame==NULL) {
        sqlite3_close(handle);
        return -1;
    }

    uint8_t *videoBuffer;
    int16_t *audioBuffer;

    int numVideoBytes;
    int numAudioBytes;
    // Determine required buffer size and allocate buffer
    numVideoBytes=avpicture_get_size(PIX_FMT_YUV420P, pVideoCodecCtx->width, pVideoCodecCtx->height);
    videoBuffer=(uint8_t *)av_mallocz(numVideoBytes*sizeof(uint8_t));
    numAudioBytes = AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE;
    audioBuffer=(int16_t *)av_mallocz(numAudioBytes);

    // Assign appropriate parts of videoBuffer to image planes in pVideoFrameYUV
    // Note that pVideoFrameYUV is an AVFrame, but AVFrame is a superset of AVPicture
    avpicture_fill((AVPicture *)pVideoFrameYUV, videoBuffer, PIX_FMT_YUV420P, pVideoCodecCtx->width, pVideoCodecCtx->height);

    int frameFinished = 0;
    AVPacket packet;
    av_init_packet(&packet);
    struct SwsContext * sws_context;
    double fps = 0.0;

    struct timeval tv;
    gettimeofday(&tv, NULL);

    char allmovies_query[150];
    memset(allmovies_query, 0, 150);
    fps = (double)pFormatCtx->streams[videoStream]->r_frame_rate.num/(double)pFormatCtx->streams[videoStream]->r_frame_rate.den;
    //if (repeated) {
    //  filename_suffix = (int)tv.tv_sec;
    //  sprintf(filename, "%s_%d", filename, filename_suffix);
    //  sprintf(allmovies_query, "insert into allmovies (name,fps,date) values ('%s',%d,%d);", filename, (int)(fps*100), filename_suffix);
    //} else {
    sprintf(allmovies_query, "insert into allmovies (name,fps,date) values ('%s',%d,%d);", filename, (int)(fps*100), (int)tv.tv_sec);
    //}
    retval = sqlite3_exec(handle,allmovies_query,0,0,0);

    printf("%d %d\n",pAudioCodecCtx->sample_rate,pAudioCodecCtx->channels);

    i = 0;
    unsigned int offset = 0; // bytes
    //fftw_complex *in;
    int totalSamples = 0;
    //in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
    int counter = 0;
    float audioTime = 0.0;

    while(av_read_frame(pFormatCtx, &packet)>=0) {
        // Decode video
        if(packet.stream_index==videoStream) {
            // Decode video frame
            avcodec_decode_video2(pVideoCodecCtx, pVideoFrame, &frameFinished, &packet);

            // Did we get a video frame?
            if(frameFinished) {
                if (pVideoCodecCtx->pix_fmt != PIX_FMT_YUV420P) {
                    // Convert the image from its native format to YUV (PIX_FMT_YUV420P)
                    //img_convert((AVPicture *)pVideoFrameYUV, PIX_FMT_YUV420P, (AVPicture*)pVideoFrame, pVideoCodecCtx->pix_fmt, pVideoCodecCtx->width, pVideoCodecCtx->height);
                    sws_context = sws_getContext(pVideoCodecCtx->width, pVideoCodecCtx->height, pVideoCodecCtx->pix_fmt, pVideoCodecCtx->width, pVideoCodecCtx->height, PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);

                    sws_scale(sws_context, pVideoFrame->data, pVideoFrame->linesize, 0, pVideoCodecCtx->height, pVideoFrameYUV->data, pVideoFrameYUV->linesize);
                    sws_freeContext(sws_context);

                    retval = AvgFrameImport(pVideoFrameYUV, pVideoCodecCtx->width, pVideoCodecCtx->height, i++, filename, handle, fps, fullArray);
                } else {
                    retval = AvgFrameImport(pVideoFrame, pVideoCodecCtx->width, pVideoCodecCtx->height, i++, filename, handle, fps, fullArray);
                }
            }
        }
        // Decode audio
        // http://qtdvd.com/guides/ffmpeg.html#decode
        if (packet.stream_index == audioStream) {

            offset = 0;
            int frameSize;
            int length = 0;
            memset(audioBuffer, 0, sizeof(audioBuffer));
            while (packet.size > 0) {
                //memset(audioBuffer, 0, sizeof(audioBuffer));
                frameSize = numAudioBytes;

                //Copy decoded information into audioBuffer
                //frameSize gets set as the decoded frameSize, in bytes
                length = avcodec_decode_audio3(pAudioCodecCtx, audioBuffer, &frameSize, &packet);
                if (length <= 0) { // Error, see if we can recover.
                    packet.size--;
                    packet.data++;
                }
                else {
                    //Slide pointer to next frame and update size
                    printf("read %d bytes\n", length);
                    packet.size -= length;
                    packet.data += length;

                    //Slide frame of audiobuffer
                    memcpy((uint16_t*)(audioBuffer+offset), audioBuffer, frameSize);
                    //Update offset
                    offset += frameSize;
                }

                //Do something with audioBuffer
                //in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
                //if (counter%2)
                //	printf("%f R: %d\n", audioTime, (int16_t)*audioBuffer);
                //else
                //	printf("%f L: %d\n", audioTime, (int16_t)*audioBuffer);
                printf("%f %d\n", audioTime, (int16_t)*audioBuffer);
                fflush(stdout);

            }


            if (offset == 0)
                samples = 0;
            else
                samples = (unsigned int)offset/sizeof(short);

            totalSamples+=samples;

            if (counter%2)
                audioTime+=samples*1.0/pAudioCodecCtx->sample_rate;

            counter++;

        }
    }

    printf("Total time (s) (per audio sample calculation): %f\n",(float)(totalSamples*1.0/pAudioCodecCtx->sample_rate/pAudioCodecCtx->channels));

    //Cut the large fullArray to the movie actual size
    int *shortArray = (int*) calloc ( i, sizeof (int));
    memcpy(shortArray, fullArray, i*sizeof(int));
    free(fullArray);

    //Do magic
    makeIndexes(shortArray, handle, filename, threshold, i, fps);

    // Free the packet that was allocated by av_read_frame
    av_free_packet(&packet);

    // Free the YUV image
    av_free(videoBuffer);
    av_free(audioBuffer);
    av_free(pVideoFrameYUV);

    // Free the YUV frame
    av_free(pVideoFrame);
    av_free(pAudioFrame);

    // Close the codec
    avcodec_close(pVideoCodecCtx);
    avcodec_close(pAudioCodecCtx);

    // Close the video file
    av_close_input_file(pFormatCtx);

    // Close DB handler
    sqlite3_close(handle);

    // Free full array
    free(shortArray);

    return 0;
}
int pysqlite_connection_init(pysqlite_Connection* self, PyObject* args, PyObject* kwargs)
{
    static char *kwlist[] = {
        "database", "timeout", "detect_types", "isolation_level",
        "check_same_thread", "factory", "cached_statements", "uri",
        NULL
    };

    char* database;
    int detect_types = 0;
    PyObject* isolation_level = NULL;
    PyObject* factory = NULL;
    int check_same_thread = 1;
    int cached_statements = 100;
    int uri = 0;
    double timeout = 5.0;
    int rc;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|diOiOip", kwlist,
                                     &database, &timeout, &detect_types,
                                     &isolation_level, &check_same_thread,
                                     &factory, &cached_statements, &uri))
    {
        return -1;
    }

    self->initialized = 1;

    self->begin_statement = NULL;

    self->statement_cache = NULL;
    self->statements = NULL;
    self->cursors = NULL;

    Py_INCREF(Py_None);
    self->row_factory = Py_None;

    Py_INCREF(&PyUnicode_Type);
    self->text_factory = (PyObject*)&PyUnicode_Type;

#ifdef SQLITE_OPEN_URI
    Py_BEGIN_ALLOW_THREADS
    rc = sqlite3_open_v2(database, &self->db,
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
                         (uri ? SQLITE_OPEN_URI : 0), NULL);
#else
    if (uri) {
        PyErr_SetString(pysqlite_NotSupportedError, "URIs not supported");
        return -1;
    }
    Py_BEGIN_ALLOW_THREADS
    rc = sqlite3_open(database, &self->db);
#endif
    Py_END_ALLOW_THREADS

    if (rc != SQLITE_OK) {
        _pysqlite_seterror(self->db, NULL);
        return -1;
    }

    if (!isolation_level) {
        isolation_level = PyUnicode_FromString("");
        if (!isolation_level) {
            return -1;
        }
    } else {
        Py_INCREF(isolation_level);
    }
    self->isolation_level = NULL;
    if (pysqlite_connection_set_isolation_level(self, isolation_level) < 0) {
        Py_DECREF(isolation_level);
        return -1;
    }
    Py_DECREF(isolation_level);

    self->statement_cache = (pysqlite_Cache*)PyObject_CallFunction((PyObject*)&pysqlite_CacheType, "Oi", self, cached_statements);
    if (PyErr_Occurred()) {
        return -1;
    }

    self->created_statements = 0;
    self->created_cursors = 0;

    /* Create lists of weak references to statements/cursors */
    self->statements = PyList_New(0);
    self->cursors = PyList_New(0);
    if (!self->statements || !self->cursors) {
        return -1;
    }

    /* By default, the Cache class INCREFs the factory in its initializer, and
     * decrefs it in its deallocator method. Since this would create a circular
     * reference here, we're breaking it by decrementing self, and telling the
     * cache class to not decref the factory (self) in its deallocator.
     */
    self->statement_cache->decref_factory = 0;
    Py_DECREF(self);

    self->detect_types = detect_types;
    self->timeout = timeout;
    (void)sqlite3_busy_timeout(self->db, (int)(timeout*1000));
#ifdef WITH_THREAD
    self->thread_ident = PyThread_get_thread_ident();
#endif
    if (!check_same_thread && sqlite3_libversion_number() < 3003001) {
        PyErr_SetString(pysqlite_NotSupportedError, "shared connections not available");
        return -1;
    }
    self->check_same_thread = check_same_thread;

    self->function_pinboard = PyDict_New();
    if (!self->function_pinboard) {
        return -1;
    }

    self->collations = PyDict_New();
    if (!self->collations) {
        return -1;
    }

    self->Warning               = pysqlite_Warning;
    self->Error                 = pysqlite_Error;
    self->InterfaceError        = pysqlite_InterfaceError;
    self->DatabaseError         = pysqlite_DatabaseError;
    self->DataError             = pysqlite_DataError;
    self->OperationalError      = pysqlite_OperationalError;
    self->IntegrityError        = pysqlite_IntegrityError;
    self->InternalError         = pysqlite_InternalError;
    self->ProgrammingError      = pysqlite_ProgrammingError;
    self->NotSupportedError     = pysqlite_NotSupportedError;

    return 0;
}
Example #28
0
void SQL::openDB(const char name[])
{
    sqlite3_open(name, &db);
}
Example #29
0
File: main.c Project: lr6666/duan
int main(void)
{
    int  lfd;
    int cfd;
    int sfd;
    int rdy;
    
    struct sockaddr_in sin;
    struct sockaddr_in cin;

    int client[FD_SETSIZE];  /* 客户端连接的套接字描述符数组 */

    int maxi;
    int maxfd;                        /* 最大连接数 */

    fd_set rset;
    fd_set allset;

    socklen_t addr_len;         /* 地址结构长度 */

    int i;
    int n;
    int len;
    int opt = 1;   /* 套接字选项 */

    char addr_p[20];

    sqlite3 *db = NULL;
    char *err_msg = NULL;
    msg_t msg;
    time_t ptime;
    char pestime[100] = {0};

                                                   /* 对server_addr_in  结构进行赋值  */
    bzero(&sin,sizeof(struct sockaddr_in));        /* 先清零 */
    sin.sin_family=AF_INET;                 
    sin.sin_addr.s_addr=htonl(INADDR_ANY);         //表示接受任何ip地址   将ip地址转换成网络字节序
    sin.sin_port=htons(PORT);                      //将端口号转换成网络字节序

                                                   /* 调用socket函数创建一个TCP协议套接口 */
    if((lfd=socket(AF_INET,SOCK_STREAM,0))==-1)    // AF_INET:IPV4;SOCK_STREAM:TCP
    {
        fprintf(stderr,"Socket error:%s\n\a",strerror(errno));
        exit(1);
    }


    /*设置套接字选项 使用默认选项*/
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    /* 调用bind函数 将serer_addr结构绑定到sockfd上  */
    if(bind(lfd,(struct sockaddr *)(&sin),sizeof(struct sockaddr))==-1)
    {
        fprintf(stderr,"Bind error:%s\n\a",strerror(errno));
        exit(1);
    }


    /* 开始监听端口   等待客户的请求 */
    if(listen(lfd,20)==-1)
    {
        fprintf(stderr,"Listen error:%s\n\a",strerror(errno));
        exit(1);
    }

    printf("Accepting connections .......\n");

    maxfd = lfd;                                /*对最大文件描述符进行初始化*/
    maxi = -1;

    /*初始化客户端连接描述符集合*/
    for(i = 0;i < FD_SETSIZE;i++)
    {
        client[i] = -1;
    }

    FD_ZERO(&allset);                     /* 清空文件描述符集合 */
    FD_SET(lfd,&allset);                    /* 将监听字设置在集合内 */


    int rc = sqlite3_open("chat_room.db",&db);
    if(rc != SQLITE_OK)
    {
        fprintf(stderr,"open database failed %s\n",sqlite3_errmsg(db));
    }

    char sql_create_user_info[256] = {0};            //保存用户信息
    sprintf(sql_create_user_info,"create table user_info(id INTEGER,name TEXT,password TEXT,primary key(id));");
    sqlite3_exec(db,sql_create_user_info,NULL,0,&err_msg);

    char sql_create_log_info[256] = {0};             //保存已登录用户
    sprintf(sql_create_log_info,"create table log_info(id INTEGER,name TEXT,connectfd INTEGER,primary key(id));");
    sqlite3_exec(db,sql_create_log_info,NULL,0,&err_msg);

    char sql_create_record[256] = {0};               //保存服务器运行记录
    sprintf(sql_create_record,"create table record(id INTEGER,name TEXT,size TEXT,target TEXT,msg TEXT,time TEXT,primary key(id));");
    sqlite3_exec(db,sql_create_record,NULL,0,&err_msg);

    /* 开始服务程序的死循环 */
    while(1)
    {
        rset = allset;
        /*得到当前可以读的文件描述符数*/
        rdy = select(maxfd + 1, &rset, NULL, NULL, NULL);

            if(FD_ISSET(lfd, &rset))
            {
                addr_len = sizeof(sin);

                /* 接受客户端的请求 */
                if((cfd=accept(lfd,(struct sockaddr *)(&cin),&addr_len))==-1)
                {
                    fprintf(stderr,"Accept error:%s\n\a",strerror(errno));
                    exit(1);
                }

                /*查找一个空闲位置*/
                for(i = 0; i<FD_SETSIZE; i++)
                {       //printf("%d\t",client[i]);
                    if(client[i] <= 0)
                    {
                        client[i] = cfd;   /* 将处理该客户端的连接套接字设置到该位置 */
                        break;
                    }
                }

                /* 太多的客户端连接   服务器拒绝俄请求  跳出循环 */
                if(i == FD_SETSIZE)
                {
                    printf("too many clients");
                    exit(1);
                }

                FD_SET(cfd, &allset);     /* 设置连接集合 */

                if(cfd > maxfd)                  /* 新的连接描述符 */
                {
                    maxfd = cfd;
                }

                if(i > maxi)
                {
                    maxi = i;
                }

                if(--rdy <= 0)                /* 减少一个连接描述符 */
                {
                    continue;
                }

            }
        /* 对每一个连接描述符做处理 */
        for(i = 0;i< FD_SETSIZE;i++)
        {   
            if((sfd = client[i]) < 0)
            {
                continue;
            }

            if(FD_ISSET(sfd, &rset))
            {
                n = read(sfd,&msg,sizeof(msg_t));

                if(n == 0)                                //客户端异常退出
                {                                     
                    printf("the other side has been closed. \n");              
                    char sql_quit[256];                   //删除登录状态
                    sprintf(sql_quit, "delete from log_info where connectfd = %d;", sfd);
                    rc = sqlite3_exec(db,sql_quit,NULL,0,&err_msg);
                    if(rc != SQLITE_OK)
                    {    
                        fprintf(stderr,"%s",err_msg);
                    }

                    time(&ptime);                         //保存记录
                    strcpy(pestime,ctime(&ptime));
                    rc = sqlite3_exec(db, sql_quit, NULL, 0, &err_msg);
                    sprintf(sql_quit, "insert into record (id,name,size,time) values(%d,'%s','%s','%s');",msg.id,msg.name,"下线",pestime); 

                    rc = sqlite3_exec(db, sql_quit, NULL, 0, &err_msg);
                    
                    memset(&msg,0,sizeof(msg_t));
                    
                    fflush(stdout);                                    /* 刷新 输出终端 */
                    close(sfd);

                    FD_CLR(sfd, &allset);                        /*清空连接描述符数组*/
                    client[i] = -1;
                }

                else
                {
                    msg_handle(&msg,sfd);
                    /* 谐函数出错 */
                    if(n == 1)
                    {
                        exit(1);
                    }
                }

                /*如果没有可以读的套接字   退出循环*/
                if(--rdy <= 0)
                {
                    break;
                }


            }
        }

    }

    close(lfd);       /* 关闭链接套接字 */
    return 0;
}
Example #30
0
int64 auth_verify_from_mydb_by_client(const char* guest, char* accesstoken, int accesslen)
{
    int ret, row, col;
    sqlite3 *db = NULL;
    char *errmsg = NULL, **result, sql[1024];
    uint64 time;
    int64 uid;

    // open database
    ret = sqlite3_open("./auth.db", &db);
    if (ret != SQLITE_OK) {
        LOGGER_ERROR("auth_verify_from_mydb_by_client open error: %s", sqlite3_errmsg(db));
        goto QUIT;
    }

    // check table exist
    snprintf(sql, sizeof(sql), "select count(*) from sqlite_master where type='table' and name='guest'");
    ret = sqlite3_get_table(db, sql, &result, &row, &col, &errmsg);
    if (ret != SQLITE_OK) {
        LOGGER_ERROR("auth_verify_from_mydb_by_client check table exist error: %d, %s", sqlite3_errcode(db), sqlite3_errmsg(db));
        goto QUIT;
    }

    // if not exist then create
    if (atoi(result[1]) <= 0) {
        snprintf(sql, sizeof(sql), "create table guest(uid integer primary key autoincrement, name varchar(128), token varchar(128), time datatime)");
        ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK) {
            LOGGER_ERROR("auth_verify_from_mydb_by_client create table error: %d, %s", sqlite3_errcode(db), sqlite3_errmsg(db));
            goto QUIT;
        }
    }

    // check guest if exist
    snprintf(sql, sizeof(sql), "select * from guest where name='%s'", guest);
    ret = sqlite3_get_table(db, sql, &result, &row, &col, &errmsg);
    if (ret != SQLITE_OK) {
        LOGGER_ERROR("auth_verify_from_mydb_by_client get table error: %d, %s", sqlite3_errcode(db), sqlite3_errmsg(db));
        goto QUIT;
    }

    time = GetTimeSec();
    snprintf(accesstoken, accesslen, "%lld", time);

    // if not exist then insert
    if (row <= 0) {
        snprintf(sql, sizeof(sql), "insert into guest (name, token, time) values('%s', '%s', %lld)", guest, accesstoken, time);
        ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK) {
            LOGGER_ERROR("auth_verify_from_mydb_by_client insert guest error: %s, %s", guest, sqlite3_errmsg(db));
            goto QUIT;
        }

        snprintf(sql, sizeof(sql), "select * from guest where name='%s'", guest);
        ret = sqlite3_get_table(db, sql, &result, &row, &col, &errmsg);
        if (ret != SQLITE_OK) {
            LOGGER_ERROR("auth_verify_from_mydb_by_client get table error: %d, %s", sqlite3_errcode(db), sqlite3_errmsg(db));
            goto QUIT;
        }
    } else {
        snprintf(sql, sizeof(sql), "update guest set token='%s', time=%lld where name='%s'", accesstoken, time, guest);
        ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
        if (ret != SQLITE_OK) {
            LOGGER_ERROR("auth_verify_from_mydb_by_client update guest error: %s, %s", guest, sqlite3_errmsg(db));
            goto QUIT;
        }
    }

    uid = atoll(result[col]);

QUIT:
    if (db) sqlite3_close(db);
    if (errmsg) sqlite3_free(errmsg);

    return uid;
}