/** * \brief clean the database */ int DBInsertClean() { memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"BEGIN;"); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); /** delete uploadtree info */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM uploadtree WHERE upload_fk = %ld;", upload_pk); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); /** delete upload info */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM upload WHERE upload_pk = %ld;", upload_pk); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); /** delete pfile info */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_pk = %ld;", pfile_pk); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"COMMIT;"); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); if (pgConn) PQfinish(pgConn); return 0; }
/** * \brief for function DBLoadMime */ void testDBLoadMime() { char SQL[MAXCMD] = {0}; PGresult *result = NULL; char mimetype_name[] = "application/octet-stream"; /** delete the record mimetype_name is application/octet-stream in mimetype */ memset(SQL, '\0', MAXCMD); snprintf(SQL, MAXCMD, "DELETE FROM mimetype where mimetype_name = '%s';", mimetype_name); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__)) { PQfinish(pgConn); exit(-1); } PQclear(result); memset(SQL, '\0', MAXCMD); snprintf(SQL, MAXCMD, "INSERT INTO mimetype (mimetype_name) VALUES ('%s');", mimetype_name); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__)) { PQfinish(pgConn); exit(-1); } PQclear(result); MaxDBMime = 0; /** exectue the tested function */ DBLoadMime(); /** select the record mimetype_name is application/octet-stream */ memset(SQL, '\0', MAXCMD); snprintf(SQL, MAXCMD, "SELECT mimetype_name from mimetype where mimetype_name = ('%s');", mimetype_name); result = PQexec(pgConn, SQL); if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) { PQfinish(pgConn); exit(-1); } int count = PQntuples(result); PQclear(result); CU_ASSERT_EQUAL(MaxDBMime, count); /** delete the record mimetype_name is application/octet-stream in mimetype */ memset(SQL, '\0', MAXCMD); snprintf(SQL, MAXCMD, "DELETE FROM mimetype where mimetype_name = '%s';", mimetype_name); result = PQexec(pgConn, SQL); /** reset the evn, that is clear all data in mimetype */ if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__)) { PQfinish(pgConn); exit(-1); } MaxDBMime = 0; PQclear(result); }
/** * @brief fo_tableExists() tests: * - Check for an existing table * - Check for table that does not exist * - Check for a non table entities (sequence, constraint, ...) * @return void */ void test_fo_tableExists() { PGconn* pgConn; int nonexistant_table; int existing_table; char* DBConfFile = dbConf; char* ErrorBuf; pgConn = fo_dbconnect(DBConfFile, &ErrorBuf); CU_ASSERT_PTR_NOT_NULL(pgConn); nonexistant_table = fo_tableExists(pgConn, "nonexistanttable"); CU_ASSERT_FALSE(nonexistant_table); PGresult* result = PQexec(pgConn, "CREATE table exists()"); CU_ASSERT_PTR_NOT_NULL_FATAL(result); CU_ASSERT_FALSE_FATAL(fo_checkPQcommand(pgConn, result, "create", __FILE__, __LINE__)); existing_table = fo_tableExists(pgConn, "exists"); CU_ASSERT_TRUE(existing_table); PQfinish(pgConn); return; }
/** * \brief Add a new license to license_ref table * * Adds a license to license_ref table. * * \param char $licenseName * * \return rf_pk for success, 0 for failure */ FUNCTION long add2license_ref(PGconn *pgConn, char *licenseName) { PGresult *result; char query[256]; char insert[256]; char escLicName[256]; char *specialLicenseText; long rf_pk; int len; int error; int numRows; // escape the name len = strlen(licenseName); PQescapeStringConn(pgConn, escLicName, licenseName, len, &error); if (error) printf("WARNING: %s(%d): Does license name have multibyte encoding?", __FILE__, __LINE__); /* verify the license is not already in the table */ sprintf(query, "SELECT rf_pk FROM license_ref where rf_shortname='%s' and rf_detector_type=2", escLicName); result = PQexec(pgConn, query); if (fo_checkPQresult(pgConn, result, query, "add2license_ref", __LINE__)) return 0; numRows = PQntuples(result); if (numRows) { rf_pk = atol(PQgetvalue(result, 0, 0)); return rf_pk; } /* Insert the new license */ specialLicenseText = "License by Nomos."; sprintf( insert, "insert into license_ref(rf_shortname, rf_text, rf_detector_type) values('%s', '%s', 2)", escLicName, specialLicenseText); result = PQexec(pgConn, insert); if (fo_checkPQcommand(pgConn, result, insert, __FILE__, __LINE__)) return 0; PQclear(result); /* retrieve the new rf_pk */ result = PQexec(pgConn, query); if (fo_checkPQresult(pgConn, result, query, "add2license_ref", __LINE__)) return 0; numRows = PQntuples(result); if (numRows) rf_pk = atol(PQgetvalue(result, 0, 0)); else { printf("ERROR: %s:%s:%d Just inserted value is missing. On: %s", __FILE__, "add2license_ref()", __LINE__, query); return(0); } PQclear(result); return (rf_pk); }
/** * \brief initialize */ int DBInsertInit() { char *ErrorBuf; char *upload_filename = "argmatch.c.gz"; int upload_mode = 104; char *upload_origin = "argmatch.c.gz"; char *tmp; pgConn = fo_dbconnect(DBConfFile, &ErrorBuf); if (!pgConn) { LOG_FATAL("Unable to connect to database"); exit(-1); } /** insert upload info */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO upload (upload_filename,upload_mode,upload_origin) VALUES ('%s', %d, '%s');",upload_filename, upload_mode, upload_origin); result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) { printf("Insert upload information ERROR!\n"); return (-1); } PQclear(result); /* select the upload pk */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"SELECT upload_pk FROM upload WHERE upload_filename = '%s';", upload_filename); result = PQexec(pgConn, SQL); /* SELECT */ if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) return(-1); tmp = PQgetvalue(result,0,0); if(tmp) { Upload_Pk = tmp; upload_pk = atol(tmp); } PQclear(result); return 0; }
/** * \brief simple wrapper which includes PQexec and fo_checkPQcommand * \param desc description for the SQL command, else NULL * \param SQL SQL command executed * \param file source file name * \param line source line number * \return PQexec query result * \see PQexec() */ PGresult * PQexecCheck(const char *desc, char *SQL, char *file, const int line) { PGresult *result; if(desc == NULL) { printfInCaseOfVerbosity("# %s:%i: %s\n", file, line, SQL); } else { printfInCaseOfVerbosity("# %s:%i: %s (%s)\n", file, line, desc, SQL); } result = PQexec(pgConn, SQL); if (fo_checkPQcommand(pgConn, result, SQL, file, line)) { exitNow(-1); } return result; }
/** * \brief Prepare database * * \param db_conn the database connection * \param pi the pointer of debpkginfo * * \return upload_pk on OK, -1 on failure */ long prepare_Database(PGconn *db_conn, struct debpkginfo *pi) { long upload_pk; char SQL[MAXSQL]; PGresult *result; long control_pfilepk; memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"BEGIN;"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); /* insert mimetype */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO mimetype (mimetype_name) VALUES ('application/x-rpm');"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare mimetype information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO mimetype (mimetype_name) VALUES ('application/x-debian-package');"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare mimetype information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO mimetype (mimetype_name) VALUES ('application/x-debian-source');"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare mimetype information ERROR!\n"); return (-1); } PQclear(result); /* insert pfile: fossology-web_1.4.1_all.deb */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO pfile (pfile_sha1,pfile_md5,pfile_size) VALUES ('%.40s','%.32s','%s');", "AF1DF2C4B32E4115DB5F272D9EFD0E674CF2A0BC","2239AA7DAC291B6F8D0A56396B1B8530","4560"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); /* insert pfile: control */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO pfile (pfile_sha1,pfile_md5,pfile_size) VALUES ('%.40s','%.32s','%s');", "F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810","87972FC55E2CDD2609ED85051BE50BAF","722"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); /* select pfile_pk: fossology-web_1.4.1_all.deb */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"SELECT pfile_pk FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';", "AF1DF2C4B32E4115DB5F272D9EFD0E674CF2A0BC","2239AA7DAC291B6F8D0A56396B1B8530","4560"); result = PQexec(db_conn, SQL); if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__)) { printf("Get pfile information ERROR!\n"); return (-1); } pi->pFileFk = atoi(PQgetvalue(result, 0, 0)); PQclear(result); /* select pfile_pk: control */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"SELECT pfile_pk FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';", "F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810","87972FC55E2CDD2609ED85051BE50BAF","722"); result = PQexec(db_conn, SQL); if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__)) { printf("Get pfile information ERROR!\n"); return (-1); } control_pfilepk = atoi(PQgetvalue(result, 0, 0)); PQclear(result); /* insert upload: fossology-web_1.4.1_all.deb */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO upload (upload_filename,upload_mode,upload_ts,pfile_fk) VALUES ('%s',40,now(),%ld);", "fossology-web_1.4.1_all.deb", pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); exit(-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"SELECT upload_pk FROM upload WHERE pfile_fk = '%ld';", pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__)) { printf("Get pfile information ERROR!\n"); return (-1); } upload_pk = atoi(PQgetvalue(result, 0, 0)); PQclear(result); /* insert uploadtree: fossology-web_1.4.1_all.deb */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO uploadtree (upload_fk,pfile_fk,lft,rgt,ufile_name) VALUES (%ld,%ld,1,48,'fossology-web_1.4.1_all.deb');", upload_pk, pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); /* insert uploadtree: control */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"INSERT INTO uploadtree (upload_fk,pfile_fk,lft,rgt,ufile_name) VALUES (%ld,%ld,9,10,'control');", upload_pk, control_pfilepk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"COMMIT;"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); return upload_pk; }
/** * \brief remove database * * \param db_conn the database connection * \param pi the pointer of debpkginfo * \param upload_pk * * \return 0 on OK, -1 on failure */ int remove_Database(PGconn *db_conn, struct debpkginfo *pi, long upload_pk) { char SQL[MAXSQL]; PGresult *result; memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"BEGIN;"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM mimetype;"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove mimetype information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM uploadtree WHERE upload_fk = %ld;", upload_pk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM upload WHERE upload_pk = %ld;", upload_pk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_pk = %ld;", pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database information ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';", "F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810","87972FC55E2CDD2609ED85051BE50BAF","722"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Remove pfile database 'control' ERROR!\n"); return (-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"COMMIT;"); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); return (-1); } PQclear(result); return (0); }
int main(int argc, char **argv) { char *agentDesc = "Bucket agent"; int cmdopt; int verbose = 0; int ReadFromStdin = 1; int head_uploadtree_pk = 0; PGconn *pgConn; PGresult *topresult; PGresult *result; char sqlbuf[512]; char *Delims = ",= \t\n\r"; char *token, *saveptr; int agent_pk = 0; int nomos_agent_pk = 0; int bucketpool_pk = 0; int ars_pk = 0; int readnum = 0; int rv; int hasPrules; int user_pk = 0; char *bucketpool_name; char *COMMIT_HASH; char *VERSION; char *uploadtree_tablename; char agent_rev[myBUFSIZ]; int rerun = 0; // int *bucketList; pbucketdef_t bucketDefArray = 0; pbucketdef_t tmpbucketDefArray = 0; cacheroot_t cacheroot; uploadtree_t uploadtree; uploadtree.upload_fk = 0; /* connect to the scheduler */ fo_scheduler_connect(&argc, argv, &pgConn); user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */ /* command line options */ while ((cmdopt = getopt(argc, argv, "rin:p:t:u:vc:hV")) != -1) { switch (cmdopt) { case 'i': /* "Initialize" */ PQfinish(pgConn); exit(0); case 'n': /* bucketpool_name */ ReadFromStdin = 0; bucketpool_name = optarg; /* find the highest rev active bucketpool_pk */ if (!bucketpool_pk) { bucketpool_pk = getBucketpool_pk(pgConn, bucketpool_name); if (!bucketpool_pk) printf("%s is not an active bucketpool name.\n", bucketpool_name); } break; case 'p': /* bucketpool_pk */ ReadFromStdin = 0; bucketpool_pk = atoi(optarg); /* validate bucketpool_pk */ sprintf(sqlbuf, "select bucketpool_pk from bucketpool where bucketpool_pk=%d and active='Y'", bucketpool_pk); bucketpool_pk = validate_pk(pgConn, sqlbuf); if (!bucketpool_pk) printf("%d is not an active bucketpool_pk.\n", atoi(optarg)); break; case 't': /* uploadtree_pk */ ReadFromStdin = 0; if (uploadtree.upload_fk) break; head_uploadtree_pk = atoi(optarg); /* validate bucketpool_pk */ sprintf(sqlbuf, "select uploadtree_pk from uploadtree where uploadtree_pk=%d", head_uploadtree_pk); head_uploadtree_pk = validate_pk(pgConn, sqlbuf); if (!head_uploadtree_pk) printf("%d is not an active uploadtree_pk.\n", atoi(optarg)); break; case 'u': /* upload_pk */ ReadFromStdin = 0; if (!head_uploadtree_pk) { uploadtree.upload_fk = atoi(optarg); /* validate upload_pk and get uploadtree_pk */ sprintf(sqlbuf, "select upload_pk from upload where upload_pk=%d", uploadtree.upload_fk); uploadtree.upload_fk = validate_pk(pgConn, sqlbuf); if (!uploadtree.upload_fk) printf("%d is not an valid upload_pk.\n", atoi(optarg)); else { sprintf(sqlbuf, "select uploadtree_pk from uploadtree where upload_fk=%d and parent is null", uploadtree.upload_fk); head_uploadtree_pk = validate_pk(pgConn, sqlbuf); } } break; case 'v': /* verbose output for debugging */ verbose++; break; case 'c': break; /* handled by fo_scheduler_connect() */ case 'r': rerun = 1; /** rerun bucket */ break; case 'V': /* print version info */ printf("%s", BuildVersion); PQfinish(pgConn); exit(0); default: Usage(argv[0]); PQfinish(pgConn); exit(-1); } } debug = verbose; /*** validate command line ***/ if (!bucketpool_pk && !ReadFromStdin) { printf("FATAL: You must specify an active bucketpool.\n"); Usage(argv[0]); exit(-1); } if (!head_uploadtree_pk && !ReadFromStdin) { printf("FATAL: You must specify a valid uploadtree_pk or upload_pk.\n"); Usage(argv[0]); exit(-1); } /* get agent pk * Note, if GetAgentKey fails, this process will exit. */ COMMIT_HASH = fo_sysconfig("buckets", "COMMIT_HASH"); VERSION = fo_sysconfig("buckets", "VERSION"); sprintf(agent_rev, "%s.%s", VERSION, COMMIT_HASH); agent_pk = fo_GetAgentKey(pgConn, basename(argv[0]), uploadtree.upload_fk, agent_rev, agentDesc); /*** Initialize the license_ref table cache ***/ /* Build the license ref cache to hold 2**11 (2048) licenses. This MUST be a power of 2. */ cacheroot.maxnodes = 2<<11; cacheroot.nodes = calloc(cacheroot.maxnodes, sizeof(cachenode_t)); if (!lrcache_init(pgConn, &cacheroot)) { printf("FATAL: Bucket agent could not allocate license_ref table cache.\n"); exit(1); } /* main processing loop */ while(++readnum) { uploadtree.upload_fk = 0; if (ReadFromStdin) { bucketpool_pk = 0; /* Read the bucketpool_pk and upload_pk from stdin. * Format looks like 'bppk=123, upk=987' */ if (!fo_scheduler_next()) break; token = strtok_r(fo_scheduler_current(), Delims, &saveptr); while (token && (!uploadtree.upload_fk || !bucketpool_pk)) { if (strcmp(token, "bppk") == 0) { bucketpool_pk = atoi(strtok_r(NULL, Delims, &saveptr)); } else if (strcmp(token, "upk") == 0) { uploadtree.upload_fk = atoi(strtok_r(NULL, Delims, &saveptr)); } token = strtok_r(NULL, Delims, &saveptr); } /* Check Permissions */ if (GetUploadPerm(pgConn, uploadtree.upload_fk, user_pk) < PERM_WRITE) { LOG_ERROR("You have no update permissions on upload %d", uploadtree.upload_fk); continue; } /* From the upload_pk, get the head of the uploadtree, pfile_pk and ufile_name */ sprintf(sqlbuf, "select uploadtree_pk, pfile_fk, ufile_name, ufile_mode,lft,rgt from uploadtree \ where upload_fk='%d' and parent is null limit 1", uploadtree.upload_fk); topresult = PQexec(pgConn, sqlbuf); if (fo_checkPQresult(pgConn, topresult, sqlbuf, agentDesc, __LINE__)) return -1; if (PQntuples(topresult) == 0) { printf("ERROR: %s.%s missing upload_pk %d.\nsql: %s", __FILE__, agentDesc, uploadtree.upload_fk, sqlbuf); PQclear(topresult); continue; } head_uploadtree_pk = atol(PQgetvalue(topresult, 0, 0)); uploadtree.uploadtree_pk = head_uploadtree_pk; uploadtree.upload_fk = uploadtree.upload_fk; uploadtree.pfile_fk = atol(PQgetvalue(topresult, 0, 1)); uploadtree.ufile_name = strdup(PQgetvalue(topresult, 0, 2)); uploadtree.ufile_mode = atoi(PQgetvalue(topresult, 0, 3)); uploadtree.lft = atoi(PQgetvalue(topresult, 0, 4)); uploadtree.rgt = atoi(PQgetvalue(topresult, 0, 5)); PQclear(topresult); } /* end ReadFromStdin */ else { /* Only one input to process if from command line, so terminate if it's been done */ if (readnum > 1) break; /* not reading from stdin * Get the pfile, and ufile_name for head_uploadtree_pk */ sprintf(sqlbuf, "select pfile_fk, ufile_name, ufile_mode,lft,rgt, upload_fk from uploadtree where uploadtree_pk=%d", head_uploadtree_pk); topresult = PQexec(pgConn, sqlbuf); if (fo_checkPQresult(pgConn, topresult, sqlbuf, agentDesc, __LINE__)) { free(uploadtree.ufile_name); return -1; } if (PQntuples(topresult) == 0) { printf("FATAL: %s.%s missing root uploadtree_pk %d\n", __FILE__, agentDesc, head_uploadtree_pk); PQclear(topresult); continue; } uploadtree.uploadtree_pk = head_uploadtree_pk; uploadtree.pfile_fk = atol(PQgetvalue(topresult, 0, 0)); uploadtree.ufile_name = strdup(PQgetvalue(topresult, 0, 1)); uploadtree.ufile_mode = atoi(PQgetvalue(topresult, 0, 2)); uploadtree.lft = atoi(PQgetvalue(topresult, 0, 3)); uploadtree.rgt = atoi(PQgetvalue(topresult, 0, 4)); uploadtree.upload_fk = atoi(PQgetvalue(topresult, 0, 5)); PQclear(topresult); } /* Find the most recent nomos data for this upload. That's what we want to use to process the buckets. */ nomos_agent_pk = LatestNomosAgent(pgConn, uploadtree.upload_fk); if (nomos_agent_pk == 0) { printf("WARNING: Bucket agent called on treeitem (%d), but the latest nomos agent hasn't created any license data for this tree.\n", head_uploadtree_pk); continue; } /* at this point we know: * bucketpool_pk, bucket agent_pk, nomos agent_pk, upload_pk, * pfile_pk, and head_uploadtree_pk (the uploadtree_pk of the head tree to scan) */ /* Has the upload already been processed? If so, we are done. Don't even bother to create a bucket_ars entry. */ switch (UploadProcessed(pgConn, agent_pk, nomos_agent_pk, uploadtree.pfile_fk, head_uploadtree_pk, uploadtree.upload_fk, bucketpool_pk)) { case 1: /* upload has already been processed */ if (1 == rerun) break; printf("LOG: Duplicate request for bucket agent to process upload_pk: %d, uploadtree_pk: %d, bucketpool_pk: %d, bucket agent_pk: %d, nomos agent_pk: %d, pfile_pk: %d ignored.\n", uploadtree.upload_fk, head_uploadtree_pk, bucketpool_pk, agent_pk, nomos_agent_pk, uploadtree.pfile_fk); continue; case -1: /* SQL error, UploadProcessed() wrote error message */ continue; case 0: /* upload has not been processed */ break; } /*** Initialize the Bucket Definition List bucketDefArray ***/ bucketDefArray = initBuckets(pgConn, bucketpool_pk, &cacheroot); if (bucketDefArray == 0) { printf("FATAL: %s.%d Bucket definition for pool %d could not be initialized.\n", __FILE__, __LINE__, bucketpool_pk); exit(-2); } bucketDefArray->nomos_agent_pk = nomos_agent_pk; bucketDefArray->bucket_agent_pk = agent_pk; /* Find the correct uploadtree table name */ uploadtree_tablename = GetUploadtreeTableName(pgConn, uploadtree.upload_fk); if (!(uploadtree_tablename)) { LOG_FATAL("buckets passed invalid upload, upload_pk = %d", uploadtree.upload_fk); return(-110); } /* set uploadtree_tablename in all the bucket definition structs */ for (tmpbucketDefArray = bucketDefArray; tmpbucketDefArray->bucket_pk; tmpbucketDefArray++) { tmpbucketDefArray->uploadtree_tablename = uploadtree_tablename; } /* loop through rules (bucket defs) to see if there are any package only rules */ hasPrules = 0; for (tmpbucketDefArray = bucketDefArray; tmpbucketDefArray->bucket_pk; tmpbucketDefArray++) if (tmpbucketDefArray->applies_to == 'p') { hasPrules = 1; break; } /*** END initializing bucketDefArray ***/ /*** Initialize DEB_SOURCE and DEB_BINARY ***/ sprintf(sqlbuf, "select mimetype_pk from mimetype where mimetype_name='application/x-debian-package'"); result = PQexec(pgConn, sqlbuf); if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1; if (PQntuples(result) == 0) { printf("FATAL: (%s.%d) Missing application/x-debian-package mimetype.\n",__FILE__,__LINE__); return -1; } DEB_BINARY = atoi(PQgetvalue(result, 0, 0)); PQclear(result); sprintf(sqlbuf, "select mimetype_pk from mimetype where mimetype_name='application/x-debian-source'"); result = PQexec(pgConn, sqlbuf); if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1; if (PQntuples(result) == 0) { printf("FATAL: (%s.%d) Missing application/x-debian-source mimetype.\n",__FILE__,__LINE__); return -1; } DEB_SOURCE = atoi(PQgetvalue(result, 0, 0)); PQclear(result); /*** END Initialize DEB_SOURCE and DEB_BINARY ***/ /*** Record analysis start in bucket_ars, the bucket audit trail. ***/ if (0 == rerun) { // do not have any bucket scan on this upload snprintf(sqlbuf, sizeof(sqlbuf), "insert into bucket_ars (agent_fk, upload_fk, ars_success, nomosagent_fk, bucketpool_fk) values(%d,%d,'%s',%d,%d)", agent_pk, uploadtree.upload_fk, "false", nomos_agent_pk, bucketpool_pk); if (debug) printf("%s(%d): %s\n", __FILE__, __LINE__, sqlbuf); result = PQexec(pgConn, sqlbuf); if (fo_checkPQcommand(pgConn, result, sqlbuf, __FILE__ ,__LINE__)) return -1; PQclear(result); /* retrieve the ars_pk of the newly inserted record */ sprintf(sqlbuf, "select ars_pk from bucket_ars where agent_fk='%d' and upload_fk='%d' and ars_success='%s' and nomosagent_fk='%d' \ and bucketpool_fk='%d' and ars_endtime is null \ order by ars_starttime desc limit 1", agent_pk, uploadtree.upload_fk, "false", nomos_agent_pk, bucketpool_pk); result = PQexec(pgConn, sqlbuf); if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1; if (PQntuples(result) == 0) { printf("FATAL: (%s.%d) Missing bucket_ars record.\n%s\n",__FILE__,__LINE__,sqlbuf); return -1; } ars_pk = atol(PQgetvalue(result, 0, 0)); PQclear(result); } /*** END bucket_ars insert ***/ if (debug) printf("%s sql: %s\n",__FILE__, sqlbuf); /* process the tree for buckets Do this as a single transaction, therefore this agent must be run as a single thread. This will prevent the scheduler from consuming excess time (this is a fast agent), and allow this process to update bucket_ars. */ rv = walkTree(pgConn, bucketDefArray, agent_pk, head_uploadtree_pk, 0, hasPrules); /* if no errors and top level is a container, process the container */ if ((!rv) && (IsContainer(uploadtree.ufile_mode))) { rv = processFile(pgConn, bucketDefArray, &uploadtree, agent_pk, hasPrules); } /* Record analysis end in bucket_ars, the bucket audit trail. */ if (0 == rerun && ars_pk) { if (rv) snprintf(sqlbuf, sizeof(sqlbuf), "update bucket_ars set ars_endtime=now(), ars_success=false where ars_pk='%d'", ars_pk); else snprintf(sqlbuf, sizeof(sqlbuf), "update bucket_ars set ars_endtime=now(), ars_success=true where ars_pk='%d'", ars_pk); if (debug) printf("%s(%d): %s\n", __FILE__, __LINE__, sqlbuf); result = PQexec(pgConn, sqlbuf); if (fo_checkPQcommand(pgConn, result, sqlbuf, __FILE__ ,__LINE__)) return -1; PQclear(result); } } /* end of main processing loop */
/** * \brief Test pkgagent.c function RecordMetadataDEB() * \test * -# Create a test upload in pfile table * -# Create debpkginfo object and populate it * -# Call RecordMetadataDEB() * -# Check if meta data got inserted in DB */ void test_RecordMetadataDEB() { struct debpkginfo *pi; int data_size, i, j; char SQL[MAXSQL]; PGresult *result; char Fuid[1024]; //char *DBConfFile = NULL; /* use default Db.conf */ char *ErrorBuf; for(i=0; i<20; i++) { sprintf(Fuid+0+i*2,"%02X",'s'); } Fuid[40]='.'; for(i=0; i<16; i++) { sprintf(Fuid+41+i*2,"%02X",'m'); } Fuid[73]='.'; snprintf(Fuid+74,sizeof(Fuid)-74,"%Lu",(long long unsigned int)100); pi = (struct debpkginfo *)malloc(sizeof(struct debpkginfo)); memset(pi, 0, sizeof(struct debpkginfo)); int predictValue = 0; /* perpare testing data in database */ db_conn = fo_dbconnect(DBConfFile, &ErrorBuf); snprintf(SQL,MAXSQL,"INSERT INTO pfile (pfile_sha1,pfile_md5,pfile_size) VALUES ('%.40s','%.32s','%s');", Fuid,Fuid+41,Fuid+74); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Perpare pfile information ERROR!\n"); free(pi); exit(-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"SELECT pfile_pk FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';", Fuid,Fuid+41,Fuid+74); result = PQexec(db_conn, SQL); if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__)) { printf("Get pfile information ERROR!\n"); exit(-1); } pi->pFileFk = atoi(PQgetvalue(result, 0, 0)); PQclear(result); strncpy(pi->pkgName, "Test Pkg", sizeof(pi->pkgName)); strncpy(pi->pkgArch, "Test Arch", sizeof(pi->pkgArch)); strncpy(pi->version, "Test version", sizeof(pi->version)); strncpy(pi->maintainer, "Test maintainer", sizeof(pi->maintainer)); strncpy(pi->description, "Test description", sizeof(pi->description)); strncpy(pi->section, "Test section", sizeof(pi->section)); strncpy(pi->priority, "Test priority", sizeof(pi->priority)); strncpy(pi->homepage, "Test homepage", sizeof(pi->homepage)); strncpy(pi->source, "Test source", sizeof(pi->source)); strncpy(pi->summary, "Test summary", sizeof(pi->summary)); strncpy(pi->format, "Test format", sizeof(pi->format)); strncpy(pi->uploaders, "Test uploaders", sizeof(pi->uploaders)); strncpy(pi->standardsVersion, "Test standard", sizeof(pi->standardsVersion)); pi->installedSize = 0; data_size = 2; pi->depends = calloc(data_size, sizeof(char *)); for (j=0; j<data_size;j++){ pi->depends[j] = malloc(MAXCMD); strcpy(pi->depends[j],"Test depends"); } pi->dep_size = data_size; /* Test RecordMetadataRPM function */ int Result = RecordMetadataDEB(pi); printf("RecordMetadataDEB Result is:%d\n", Result); /* Check data correction */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"SELECT pkg_pk, pkg_name, pkg_arch, version, maintainer, description FROM pkg_deb INNER JOIN pfile ON pfile_fk = '%ld' AND pfile_fk = pfile_pk;", pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__)) { printf("Get pkg information ERROR!\n"); PQclear(result); free(pi); exit(-1); } CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 1), "Test Pkg"); CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 2), "Test Arch"); CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 3), "Test version"); CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 4), "Test maintainer"); CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 5), "Test description"); PQclear(result); /* Clear testing data in database */ memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM pkg_deb_req WHERE pkg_fk IN (SELECT pkg_pk FROM pkg_deb WHERE pfile_fk = '%ld');", pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Clear pkg_deb_req test data ERROR!\n"); PQclear(result); free(pi); exit(-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM pkg_deb WHERE pfile_fk = '%ld';", pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Clear pkg_deb test data ERROR!\n"); PQclear(result); free(pi); exit(-1); } PQclear(result); memset(SQL,'\0',MAXSQL); snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_pk = '%ld'", pi->pFileFk); result = PQexec(db_conn, SQL); if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__)) { printf("Clear pfile test data ERROR!\n"); PQclear(result); free(pi); exit(-1); } PQclear(result); PQfinish(db_conn); int k; for(k=0; k< pi->dep_size;k++) free(pi->depends[k]); free(pi->depends); memset(pi,0,sizeof(struct debpkginfo)); free(pi); CU_ASSERT_EQUAL(Result, predictValue); }
int main(int argc, char *argv[]) { int Pid; int c; int rvExist1=0, rvExist2=0; PGresult *result; char *NewDir="."; char *AgentName = "ununpack"; char *AgentARSName = "ununpack_ars"; char *agent_desc = "Unpacks archives (iso, tar, etc)"; int Recurse=0; int ars_pk = 0; int user_pk = 0; long Pfile_size = 0; char *ListOutName=NULL; char *Fname = NULL; char *FnameCheck = NULL; char *COMMIT_HASH; char *VERSION; char agent_rev[PATH_MAX]; struct stat Stat; /* connect to the scheduler */ fo_scheduler_connect(&argc, argv, &pgConn); while((c = getopt(argc,argv,"ACc:d:FfHhL:m:PQiqRr:T:t:U:VvXx")) != -1) { switch(c) { case 'A': SetContainerArtifact=0; break; case 'C': ForceContinue=1; break; case 'c': break; /* handled by fo_scheduler_connect() */ case 'd': /* if there is a %U in the path, substitute a unique ID */ NewDir=PathCheck(optarg); break; case 'F': UseRepository=1; break; case 'f': ForceDuplicate=1; break; case 'L': ListOutName=optarg; break; case 'm': MaxThread = atoi(optarg); if (MaxThread < 1) MaxThread=1; break; case 'P': PruneFiles=1; break; case 'R': Recurse=-1; break; case 'r': Recurse=atoi(optarg); break; case 'i': if (!IsExe("dpkg-source",Quiet)) LOG_WARNING("dpkg-source is not available on this system. This means that debian source packages will NOT be unpacked."); SafeExit(0); break; /* never reached */ case 'Q': UseRepository=1; user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */ /* Get the upload_pk from the scheduler */ if((Upload_Pk = fo_scheduler_next()) == NULL) SafeExit(0); break; case 'q': Quiet=1; break; case 'T': memset(REP_GOLD,0,sizeof(REP_GOLD)); strncpy(REP_GOLD,optarg,sizeof(REP_GOLD)-1); break; case 't': memset(REP_FILES,0,sizeof(REP_FILES)); strncpy(REP_FILES,optarg,sizeof(REP_FILES)-1); break; case 'U': UseRepository = 1; Recurse = -1; Upload_Pk = optarg; break; case 'V': printf("%s", BuildVersion);SafeExit(0); case 'v': Verbose++; break; case 'X': UnlinkSource=1; break; case 'x': UnlinkAll=1; break; default: Usage(argv[0], BuildVersion); SafeExit(25); } } /* Open DB and Initialize CMD table */ if (UseRepository) { /* Check Permissions */ if (GetUploadPerm(pgConn, atoi(Upload_Pk), user_pk) < PERM_WRITE) { LOG_ERROR("You have no update permissions on upload %s", Upload_Pk); SafeExit(100); } COMMIT_HASH = fo_sysconfig(AgentName, "COMMIT_HASH"); VERSION = fo_sysconfig(AgentName, "VERSION"); sprintf(agent_rev, "%s.%s", VERSION, COMMIT_HASH); /* Get the unpack agent key */ agent_pk = fo_GetAgentKey(pgConn, AgentName, atoi(Upload_Pk), agent_rev,agent_desc); InitCmd(); /* Make sure ars table exists */ if (!fo_CreateARSTable(pgConn, AgentARSName)) SafeExit(0); /* Has this user previously unpacked this upload_pk successfully? * In this case we are done. No new ars record is needed since no * processing is initiated. * The unpack version is ignored. */ snprintf(SQL,MAXSQL, "SELECT ars_pk from %s where upload_fk='%s' and ars_success=TRUE", AgentARSName, Upload_Pk); result = PQexec(pgConn, SQL); if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(101); if (PQntuples(result) > 0) /* if there is a value */ { PQclear(result); LOG_WARNING("Upload_pk %s, has already been unpacked. No further action required", Upload_Pk) SafeExit(0); } PQclear(result); /* write the unpack_ars start record */ ars_pk = fo_WriteARS(pgConn, ars_pk, atoi(Upload_Pk), agent_pk, AgentARSName, 0, 0); /* Get Pfile path and Pfile_Pk, from Upload_Pk */ snprintf(SQL,MAXSQL, "SELECT pfile.pfile_sha1 || '.' || pfile.pfile_md5 || '.' || pfile.pfile_size AS pfile, pfile_fk, pfile_size FROM upload INNER JOIN pfile ON upload.pfile_fk = pfile.pfile_pk WHERE upload.upload_pk = '%s'", Upload_Pk); result = PQexec(pgConn, SQL); if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(102); if (PQntuples(result) > 0) /* if there is a value */ { Pfile = strdup(PQgetvalue(result,0,0)); Pfile_Pk = strdup(PQgetvalue(result,0,1)); Pfile_size = atol(PQgetvalue(result, 0, 2)); if (Pfile_size == 0) { PQclear(result); LOG_WARNING("Uploaded file (Upload_pk %s), is zero length. There is nothing to unpack.", Upload_Pk) SafeExit(0); } PQclear(result); } // Determine if uploadtree records should go into a separate table. // If the input file size is > 500MB, then create a separate uploadtree_{upload_pk} table // that inherits from the master uploadtree table. // Save uploadtree_tablename, it will get written to upload.uploadtree_tablename later. if (Pfile_size > 500000000) { sprintf(uploadtree_tablename, "uploadtree_%s", Upload_Pk); if (!fo_tableExists(pgConn, uploadtree_tablename)) { snprintf(SQL,MAXSQL,"CREATE TABLE %s (LIKE uploadtree INCLUDING DEFAULTS INCLUDING CONSTRAINTS INCLUDING INDEXES); ALTER TABLE %s ADD CONSTRAINT %s CHECK (upload_fk=%s); ALTER TABLE %s INHERIT uploadtree", uploadtree_tablename, uploadtree_tablename, uploadtree_tablename, Upload_Pk, uploadtree_tablename); PQsetNoticeProcessor(pgConn, SQLNoticeProcessor, SQL); // ignore notice about implicit primary key index creation result = PQexec(pgConn, SQL); // Ignore postgres notice about creating an implicit index if (PQresultStatus(result) != PGRES_NONFATAL_ERROR) if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(103); PQclear(result); } } else strcpy(uploadtree_tablename, "uploadtree_a"); } CheckCommands(Quiet); if (NewDir) MkDir(NewDir); if (Verbose) { fclose(stderr) ; stderr=stdout; } /* don't interlace! */ if (ListOutName != NULL) { if ((ListOutName[0]=='-') && (ListOutName[1]=='\0')) ListOutFile=stdout; else ListOutFile = fopen(ListOutName,"w"); if (!ListOutFile) { LOG_ERROR("pfile %s Unable to write to %s\n",Pfile_Pk,ListOutName) SafeExit(104); } else { /* Start the file */ fputs("<xml tool=\"ununpack\" ",ListOutFile); fputs("version=\"",ListOutFile); fputs(Version,ListOutFile); fputs("\" ",ListOutFile); fputs("compiled_date=\"",ListOutFile); fputs(__DATE__,ListOutFile); fputs(" ",ListOutFile); fputs(__TIME__,ListOutFile); fputs("\"",ListOutFile); fputs(">\n",ListOutFile); } /* Problem: When parallel processing, the XML may be generated out of order. Solution? When using XML, only use 1 thread. */ MaxThread=1; } // Set ReunpackSwitch if the uploadtree records are missing from the database. if (!ReunpackSwitch && UseRepository) { snprintf(SQL,MAXSQL,"SELECT uploadtree_pk FROM uploadtree WHERE upload_fk=%s limit 1;",Upload_Pk); result = PQexec(pgConn, SQL); if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(105); if (PQntuples(result) == 0) ReunpackSwitch=1; PQclear(result); } /*** process files from command line ***/ for( ; optind<argc; optind++) { CksumFile *CF=NULL; Cksum *Sum; int i; if (Fname) { free(Fname); Fname=NULL; } if (ListOutName != NULL) { fprintf(ListOutFile,"<source source=\"%s\" ",argv[optind]); if (UseRepository && !fo_RepExist(REP_FILES,argv[optind])) { /* make sure the source exists in the src repository */ if (fo_RepImport(argv[optind],REP_FILES,argv[optind],1) != 0) { LOG_ERROR("Failed to import '%s' as '%s' into the repository",argv[optind],argv[optind]) SafeExit(106); } } } if (UseRepository) { if (fo_RepExist(REP_FILES,argv[optind])) { Fname=fo_RepMkPath(REP_FILES,argv[optind]); } else if (fo_RepExist(REP_GOLD,argv[optind])) { Fname=fo_RepMkPath(REP_GOLD,argv[optind]); if (fo_RepImport(Fname,REP_FILES,argv[optind],1) != 0) { LOG_ERROR("Failed to import '%s' as '%s' into the repository",Fname,argv[optind]) SafeExit(107); } } if (Fname) { FnameCheck = Fname; CF = SumOpenFile(Fname); } else { LOG_ERROR("NO file unpacked. File %s does not exist either in GOLD or FILES", Pfile); SafeExit(108); } /* else: Fname is NULL and CF is NULL */ } else { FnameCheck = argv[optind]; CF = SumOpenFile(argv[optind]); } /* Check file to unpack. Does it exist? Is it zero length? */ if (stat(FnameCheck,&Stat)) { LOG_ERROR("File to unpack is unavailable: %s, error: %s", Fname, strerror(errno)); SafeExit(109); } else if (Stat.st_size < 1) { LOG_WARNING("File to unpack is empty: %s", Fname); SafeExit(110); } if (ListOutFile) { if (CF) { Sum = SumComputeBuff(CF); SumCloseFile(CF); if (Sum) { fputs("fuid=\"",ListOutFile); for(i=0; i<20; i++) { fprintf(ListOutFile,"%02X",Sum->SHA1digest[i]); } fputs(".",ListOutFile); for(i=0; i<16; i++) { fprintf(ListOutFile,"%02X",Sum->MD5digest[i]); } fputs(".",ListOutFile); fprintf(ListOutFile,"%Lu",(long long unsigned int)Sum->DataLen); fputs("\" ",ListOutFile); free(Sum); } /* if Sum */ } /* if CF */ else /* file too large to mmap (probably) */ { FILE *Fin; Fin = fopen(argv[optind],"rb"); if (Fin) { Sum = SumComputeFile(Fin); if (Sum) { fputs("fuid=\"",ListOutFile); for(i=0; i<20; i++) { fprintf(ListOutFile,"%02X",Sum->SHA1digest[i]); } fputs(".",ListOutFile); for(i=0; i<16; i++) { fprintf(ListOutFile,"%02X",Sum->MD5digest[i]); } fputs(".",ListOutFile); fprintf(ListOutFile,"%Lu",(long long unsigned int)Sum->DataLen); fputs("\" ",ListOutFile); free(Sum); } fclose(Fin); } } /* else no CF */ fprintf(ListOutFile,">\n"); /* end source XML */ } if (Fname) TraverseStart(Fname,"called by main via args",NewDir,Recurse); else TraverseStart(argv[optind],"called by main",NewDir,Recurse); if (ListOutName != NULL) fprintf(ListOutFile,"</source>\n"); } /* end for */ /* free memory */ if (Fname) { free(Fname); Fname=NULL; } /* process pfile from scheduler */ if (Pfile) { if (0 == (rvExist1 = fo_RepExist2(REP_FILES,Pfile))) { Fname=fo_RepMkPath(REP_FILES,Pfile); } else if (0 == (rvExist2 = fo_RepExist2(REP_GOLD,Pfile))) { Fname=fo_RepMkPath(REP_GOLD,Pfile); if (fo_RepImport(Fname,REP_FILES,Pfile,1) != 0) { LOG_ERROR("Failed to import '%s' as '%s' into the repository",Fname,Pfile) SafeExit(111); } } if (Fname) { TraverseStart(Fname,"called by main via env",NewDir,Recurse); free(Fname); Fname=NULL; } else { LOG_ERROR("NO file unpacked!"); if (rvExist1 > 0) { Fname=fo_RepMkPath(REP_FILES, Pfile); LOG_ERROR("Error is %s for %s", strerror(rvExist1), Fname); } if (rvExist2 > 0) { Fname=fo_RepMkPath(REP_GOLD, Pfile); LOG_ERROR("Error is %s for %s", strerror(rvExist2), Fname); } SafeExit(112); } } /* recurse on all the children */ if (Thread > 0) do { Pid = ParentWait(); Thread--; if (Pid >= 0) { if (!Queue[Pid].ChildEnd) { /* copy over data */ if (Recurse > 0) Traverse(Queue[Pid].ChildRecurse,NULL,"called by wait",NULL,Recurse-1,&Queue[Pid].PI); else if (Recurse < 0) Traverse(Queue[Pid].ChildRecurse,NULL,"called by wait",NULL,Recurse,&Queue[Pid].PI); } } } while(Pid >= 0); if (MagicCookie) magic_close(MagicCookie); if (ListOutFile) { fprintf(ListOutFile,"<summary files_regular=\"%d\" files_compressed=\"%d\" artifacts=\"%d\" directories=\"%d\" containers=\"%d\" />\n", TotalFiles,TotalCompressedFiles,TotalArtifacts, TotalDirectories,TotalContainers); fputs("</xml>\n",ListOutFile); } if (pgConn) { /* If it completes, mark it! */ if (Upload_Pk) { snprintf(SQL,MAXSQL,"UPDATE upload SET upload_mode = (upload_mode | (1<<5)), uploadtree_tablename='%s' WHERE upload_pk = '%s';",uploadtree_tablename, Upload_Pk); result = PQexec(pgConn, SQL); /* UPDATE upload */ if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) SafeExit(113); PQclear(result); snprintf(SQL,MAXSQL,"UPDATE %s SET realparent = getItemParent(uploadtree_pk) WHERE upload_fk = '%s'",uploadtree_tablename, Upload_Pk); result = PQexec(pgConn, SQL); /* UPDATE uploadtree */ if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) SafeExit(114); PQclear(result); } if (ars_pk) fo_WriteARS(pgConn, ars_pk, atoi(Upload_Pk), agent_pk, AgentARSName, 0, 1); } if (ListOutFile && (ListOutFile != stdout)) { fclose(ListOutFile); } if (UnlinkAll && MaxThread > 1) { /* Delete temporary files */ if (strcmp(NewDir, ".")) RemoveDir(NewDir); } SafeExit(0); return(0); // never executed but makes the compiler happy }
/**************** main *******************/ int main(int argc, char** argv) { PGconn* pgConn; PGresult* result; psqlCopy_t pCopy; char* TestTable = "TestsqlCopy"; char col_vc[40] = "This is \n\r column vc[40] 123456789\r"; char* col_text; char* DataBuf; int datasize; char sql[2048]; int NumColumns = 3; int CopyBufSize; int RowsToTest; int NumTextBytes; int RowNum; clock_t StartTime, EndTime; char* DBConfFile = NULL; /* use default Db.conf */ char* ErrorBuf; if (argc != 4) { printf("Usage: %s RowsToTest NumTextBytes CopyDataBufferSize\n", argv[0]); exit(-1); } /* first argument is the number of rows to test, * the second is the number of bytes to use for col_text * third is the Copy data buffer size */ RowsToTest = atoi(argv[1]); NumTextBytes = atoi(argv[2]); CopyBufSize = atoi(argv[3]); /* Populate test data */ col_text = GetTextCol(NumTextBytes); datasize = NumTextBytes + 8 + 40 + 1; DataBuf = calloc(datasize, sizeof(char)); if (!DataBuf) { ERROR_RETURN("Allocating test data buffer failed.") exit(-2); } pgConn = fo_dbconnect(DBConfFile, &ErrorBuf); /* Create a test table to populate */ snprintf(sql, sizeof(sql), "create table %s (col_int integer, col_text text, col_vc varchar(40))", TestTable); result = PQexec(pgConn, sql); fo_checkPQcommand(pgConn, result, sql, __FILE__, __LINE__); /* Start timer */ StartTime = clock(); /* Create the pCopy */ pCopy = fo_sqlCopyCreate(pgConn, TestTable, CopyBufSize, NumColumns, "col_int", "col_text", "col_vc"); if (!pCopy) exit(1); /* CopyCreate prints errors to stdout */ /* Add data */ for (RowNum = 0; RowNum < RowsToTest; RowNum++) { snprintf(DataBuf, datasize, "%d\t%s\t%s\n", RowNum, col_text, col_vc); fo_sqlCopyAdd(pCopy, DataBuf); } free(col_text); /* Destroy - flushes remaining data and frees */ fo_sqlCopyDestroy(pCopy, 1); /* Print run time for the load (whole Create/Add/Destroy cycle). */ EndTime = clock(); printf("%.6f Seconds to load.\n", ((double) (EndTime - StartTime)) / CLOCKS_PER_SEC); /* Verify that the right number of records were loaded */ snprintf(sql, sizeof(sql), "select count(*) from %s", TestTable); result = PQexec(pgConn, sql); fo_checkPQresult(pgConn, result, sql, __FILE__, __LINE__); printf("%d records inserted, %d expected\n", atoi(PQgetvalue(result, 0, 0)), RowsToTest); PQclear(result); /* Remove the test table */ /* snprintf(sql, sizeof(sql), "drop table %s", TestTable); result = PQexec(pgConn, sql); fo_checkPQcommand(pgConn, result, sql, __FILE__, __LINE__); */ PQfinish(pgConn); return (0); }