/**
* \brief remove repository
*
* \return 0 on OK, -1 on failure
*/
int remove_Repository()
{
char *Pfile = "F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810.87972FC55E2CDD2609ED85051BE50BAF.722";
if (fo_RepExist("files",Pfile))
{
if (fo_RepRemove("files", Pfile) != 0)
{
printf("Failed to remove %s\n", Pfile);
return (-1);
}
}
return (0);
}
/**
* \brief Prepare repository
*
* \return 0 on OK, -1 on failure
*/
int prepare_Repository()
{
char *Source = "../testdata/control";
char *Pfile = "F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810.87972FC55E2CDD2609ED85051BE50BAF.722";
if (!fo_RepExist("files",Pfile))
{
if (fo_RepImport(Source, "files", Pfile, 1) != 0)
{
printf("Failed to import %s\n", Source);
return (-1);
}
}
return (0);
}
/*****************************************
CopyFile(): Given one file, copy it.
*****************************************/
void CopyFile(char* Source, char* Type, char* Name)
{
int rc;
rc = fo_RepExist(Type, Name);
if (rc == 1)
{
TotalDuplicate++;
return;
}
else if (rc == -1)
{
TotalError++;
return;
}
if (fo_RepImport(Source, Type, Name, 1) == 0) TotalImported++;
else TotalError++;
} /* CopyFile() */
/**
* \brief Given an upload ID, delete it.
*
* \param uploadId the upload id
* \param userId
* \param userPerm permission level the user has
*
* \return 0: yes, can is deleted;
* 1: can not be deleted;
* -1: failure;
* -2: does not exist
*/
int deleteUpload (long uploadId, int userId, int userPerm)
{
char *S;
int Row,maxRow;
char tempTable[256];
PGresult *result, *pfileResult;
char SQL[MAXSQL], desc[myBUFSIZ];
int permission_upload = check_write_permission_upload(uploadId, userId, userPerm);
if(0 != permission_upload) {
return permission_upload;
}
snprintf(tempTable,sizeof(tempTable),"DelUp_%ld_pfile",uploadId);
snprintf(SQL,MAXSQL,"DROP TABLE IF EXISTS %s;",tempTable);
PQexecCheckClear(NULL, SQL, __FILE__, __LINE__);
snprintf(desc, myBUFSIZ, "Deleting upload %ld",uploadId);
PQexecCheckClear(desc, "SET statement_timeout = 0;", __FILE__, __LINE__);
PQexecCheckClear(NULL, "BEGIN;", __FILE__, __LINE__);
/* Delete everything that impacts the UI */
if (!Test) {
/* The UI depends on uploadtree and folders for navigation.
Delete them now to block timeouts from the UI. */
PQexecCheckClear(NULL, "COMMIT;", __FILE__, __LINE__);
}
/* Begin complicated stuff */
/* Get the list of pfiles to delete */
/* These are all pfiles in the upload_fk that only appear once. */
snprintf(SQL,MAXSQL,"SELECT DISTINCT pfile_pk,pfile_sha1 || '.' || pfile_md5 || '.' || pfile_size AS pfile INTO %s FROM uploadtree INNER JOIN pfile ON upload_fk = %ld AND pfile_fk = pfile_pk;",tempTable,uploadId);
PQexecCheckClear("Getting list of pfiles to delete", SQL, __FILE__, __LINE__);
/* Remove pfiles which are reused by other uploads */
snprintf(SQL, MAXSQL, "DELETE FROM %s WHERE pfile_pk IN (SELECT pfile_pk FROM %s INNER JOIN uploadtree ON pfile_pk = pfile_fk WHERE upload_fk != %ld)", tempTable, tempTable, uploadId);
PQexecCheckClear(NULL, SQL, __FILE__, __LINE__);
if (Verbose) {
snprintf(SQL,MAXSQL,"SELECT COUNT(*) FROM %s;",tempTable);
result = PQexec(pgConn, SQL);
if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) {
return -1;
}
printf("# Created pfile table %s with %ld entries\n", tempTable, atol(PQgetvalue(result,0,0)));
PQclear(result);
}
/* Now to delete the actual pfiles from the repository before remove the DB. */
/* Get the file listing -- needed for deleting pfiles from the repository. */
snprintf(SQL,MAXSQL,"SELECT * FROM %s ORDER BY pfile_pk;",tempTable);
pfileResult = PQexec(pgConn, SQL);
if (fo_checkPQresult(pgConn, pfileResult, SQL, __FILE__, __LINE__)) {
return -1;
}
if (Test <= 1) {
maxRow = PQntuples(pfileResult);
for(Row=0; Row<maxRow; Row++) {
S = PQgetvalue(pfileResult,Row,1); /* sha1.md5.len */
if (fo_RepExist("files",S)) {
if (Test) {
printf("TEST: Delete %s %s\n","files",S);
} else {
fo_RepRemove("files",S);
}
}
if (fo_RepExist("gold",S)) {
if (Test) {
printf("TEST: Delete %s %s\n","gold",S);
} else {
fo_RepRemove("gold",S);
}
}
fo_scheduler_heart(1);
}
}
PQclear(pfileResult);
/*
This begins the slow part that locks the DB.
The problem is, we don't want to lock a critical row,
otherwise the scheduler will lock and/or fail.
*/
if (!Test) {
PQexecCheckClear(NULL, "BEGIN;", __FILE__, __LINE__);
}
/* Delete the upload from the folder-contents table */
snprintf(SQL,MAXSQL,"DELETE FROM foldercontents WHERE (foldercontents_mode & 2) != 0 AND child_id = %ld;",uploadId);
PQexecCheckClear("Deleting foldercontents", SQL, __FILE__, __LINE__);
/* Deleting the actual upload contents*/
/* Delete the bucket_container record as it can't be cascade delete with upload table */
snprintf(SQL,MAXSQL,"DELETE FROM bucket_container USING uploadtree WHERE uploadtree_fk = uploadtree_pk AND upload_fk = %ld;",uploadId);
PQexecCheckClear("Deleting bucket_container", SQL, __FILE__, __LINE__);
/* Delete the tag_uploadtree record as it can't be cascade delete with upload table */
snprintf(SQL,MAXSQL,"DELETE FROM tag_uploadtree USING uploadtree WHERE uploadtree_fk = uploadtree_pk AND upload_fk = %ld;",uploadId);
PQexecCheckClear("Deleting tag_uploadtree", SQL, __FILE__, __LINE__);
/* Delete uploadtree_nnn table */
char uploadtree_tablename[1024];
snprintf(SQL,MAXSQL,"SELECT uploadtree_tablename FROM upload WHERE upload_pk = %ld;",uploadId);
result = PQexec(pgConn, SQL);
if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) {
return -1;
}
if (PQntuples(result)) {
strcpy(uploadtree_tablename, PQgetvalue(result, 0, 0));
PQclear(result);
if (strcasecmp(uploadtree_tablename,"uploadtree_a")) {
snprintf(SQL,MAXSQL,"DROP TABLE %s;", uploadtree_tablename);
PQexecCheckClear(NULL, SQL, __FILE__, __LINE__);
}
}
printfInCaseOfVerbosity("Deleting license decisions for upload %ld\n",uploadId);
/* delete from clearing_decision_event table. */
snprintf(SQL, MAXSQL, "DELETE FROM clearing_decision_event USING clearing_event WHERE clearing_decision_event.clearing_event_fk = clearing_event.clearing_event_pk AND clearing_event.uploadtree_fk IN (SELECT uploadtree_pk FROM uploadtree INNER JOIN %s ON uploadtree.pfile_fk = %s.pfile_pk WHERE upload_fk = %ld);", tempTable, tempTable, uploadId);
PQexecCheckClear("Deleting from clearing_decision_event", SQL, __FILE__, __LINE__);
/* delete from clearing_event table. */
snprintf(SQL, MAXSQL, "DELETE FROM clearing_event WHERE uploadtree_fk IN (SELECT uploadtree_pk FROM uploadtree INNER JOIN %s ON uploadtree.pfile_fk = %s.pfile_pk WHERE upload_fk = %ld);", tempTable, tempTable, uploadId);
PQexecCheckClear("Deleting from clearing_event", SQL, __FILE__, __LINE__);
/* delete from uploadtree table. */
snprintf(SQL, MAXSQL, "DELETE FROM uploadtree WHERE upload_fk = %ld;", uploadId);
PQexecCheckClear("Deleting from uploadtree", SQL, __FILE__, __LINE__);
/* delete from pfile is SLOW due to constraint checking. Do it separately. */
snprintf(SQL,MAXSQL,"DELETE FROM pfile USING %s WHERE pfile.pfile_pk = %s.pfile_pk;",tempTable,tempTable);
PQexecCheckClear("Deleting from pfile", SQL, __FILE__, __LINE__);
snprintf(SQL,MAXSQL,"DROP TABLE %s;",tempTable);
PQexecCheckClear(NULL, SQL, __FILE__, __LINE__);
PQexecCheckClear(NULL, "SET statement_timeout = 120000;", __FILE__, __LINE__);
printfInCaseOfVerbosity("Deleted upload %ld from DB, now doing repository.\n",uploadId);
if (Test) {
PQexecCheckClear(NULL, "ROLLBACK;", __FILE__, __LINE__);
} else {
PQexecCheckClear(NULL, "COMMIT;", __FILE__, __LINE__);
}
printfInCaseOfVerbosity("Deleted upload %ld\n",uploadId);
return 0; /* success */
} /* deleteUpload() */
/**
* \brief Get the mimetype for a package
* \param argc the number of command line arguments
* \param argv the command line arguments
* \return 0 on a successful program execution
*/
int main(int argc, char *argv[])
{
int arg;
char *Parm = NULL;
char *Path = NULL;
int c;
char *agent_desc = "Determines mimetype for each file";
int pfile_count = 0;
int Agent_pk;
int ars_pk = 0;
int upload_pk = 0; // the upload primary key
int user_pk = 0;
char *AgentARSName = "mimetype_ars";
int rv;
PGresult *result;
char sqlbuf[1024];
int CmdlineFlag = 0; ///< run from command line flag, 1 yes, 0 not
char *COMMIT_HASH;
char *VERSION;
char agent_rev[MAXCMD];
/* initialize the scheduler connection */
fo_scheduler_connect(&argc, argv, &pgConn);
/* Process command-line */
while((c = getopt(argc,argv,"iCc:hvV")) != -1)
{
switch(c)
{
case 'i':
PQfinish(pgConn);
return(0);
case 'c':
/* do nothing with this option */
break;
case 'C':
CmdlineFlag = 1;
break;
case 'v':
agent_verbose++;
break;
case 'V':
printf("%s", BuildVersion);
PQfinish(pgConn);
return(0);
default:
Usage(argv[0]);
PQfinish(pgConn);
exit(-1);
}
}
COMMIT_HASH = fo_sysconfig("mimetype", "COMMIT_HASH");
VERSION = fo_sysconfig("mimetype", "VERSION");
sprintf(agent_rev, "%s.%s", VERSION, COMMIT_HASH);
/* Get the Agent Key from the DB */
Agent_pk = fo_GetAgentKey(pgConn, basename(argv[0]), 0, agent_rev, agent_desc);
FMimetype = fopen("/etc/mime.types","rb");
if (!FMimetype)
{
LOG_WARNING("Unable to open /etc/mime.types\n");
}
MagicCookie = magic_open(MAGIC_PRESERVE_ATIME|MAGIC_MIME);
if (MagicCookie == NULL)
{
LOG_FATAL("Failed to initialize magic cookie\n");
PQfinish(pgConn);
exit(-1);
}
if (magic_load(MagicCookie,NULL) != 0)
{
LOG_FATAL("Failed to load magic file: UnMagic\n");
PQfinish(pgConn);
exit(-1);
}
/* Run from the command-line (for testing) */
for(arg=optind; arg < argc; arg++)
{
Akey = -1;
memset(A,'\0',sizeof(A));
strncpy(A,argv[arg],sizeof(A));
DBCheckMime(A);
}
/* Run from scheduler! */
if (0 == CmdlineFlag)
{
user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */
while(fo_scheduler_next())
{
/* get piece of information, including upload_pk, others */
Parm = fo_scheduler_current();
if (Parm && Parm[0])
{
upload_pk = atoi(Parm);
/* Check Permissions */
if (GetUploadPerm(pgConn, upload_pk, user_pk) < PERM_WRITE)
{
LOG_ERROR("You have no update permissions on upload %d", upload_pk);
continue;
}
/* does ars table exist?
* If not, create it.
*/
rv = fo_tableExists(pgConn, AgentARSName);
if (!rv)
{
rv = fo_CreateARSTable(pgConn, AgentARSName);
if (!rv) return(0);
}
/* check ars table if this is duplicate request*/
memset(sqlbuf, 0, sizeof(sqlbuf));
snprintf(sqlbuf, sizeof(sqlbuf),
"select ars_pk from mimetype_ars,agent \
where agent_pk=agent_fk and ars_success=true \
and upload_fk='%d' and agent_fk='%d'",
upload_pk, Agent_pk);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) exit(-1);
if (PQntuples(result) > 0)
{
PQclear(result);
LOG_WARNING("Ignoring requested mimetype analysis of upload %d - Results are already in database.\n",upload_pk);
continue;
}
PQclear(result);
/* Record analysis start in mimetype_ars, the mimetype audit trail. */
ars_pk = fo_WriteARS(pgConn, ars_pk, upload_pk, Agent_pk, AgentARSName, 0, 0);
/* get all pfile ids on a upload record */
memset(sqlbuf, 0, sizeof(sqlbuf));
snprintf(sqlbuf, sizeof(sqlbuf), "SELECT DISTINCT(pfile_pk) as Akey, pfile_sha1 || '.' || pfile_md5 || '.' || pfile_size AS A FROM uploadtree, pfile WHERE uploadtree.pfile_fk = pfile.pfile_pk AND pfile_mimetypefk is NULL AND upload_fk = '%d';", upload_pk);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) exit(-1);
pfile_count = PQntuples(result);
int i;
for(i=0; i < pfile_count; i++)
{
Akey = atoi(PQgetvalue(result, i, 0));
strncpy(A, PQgetvalue(result, i, 1), sizeof(A));
if (Akey <= 0 || A[0]=='\0')
{
printf("ERROR: Data is in an unknown format.\n");
PQfinish(pgConn);
exit(-1);
}
/* Process the repository file */
/* Find the path */
Path = fo_RepMkPath("files",A);
if (Path && fo_RepExist("files",A))
{
/* Get the mimetype! */
DBCheckMime(Path);
}
else
{
printf("ERROR pfile %d Unable to process.\n",Akey);
printf("LOG pfile %d File '%s' not found.\n",Akey,A);
PQfinish(pgConn);
exit(-1);
}
/* Clean up Path memory */
if(Path)
{
free(Path);
Path = NULL;
}
fo_scheduler_heart(1);
}
PQclear(result);
/* Record analysis success in mimetype_ars. */
if (ars_pk) fo_WriteARS(pgConn, ars_pk, upload_pk, Agent_pk, AgentARSName, 0, 1);
}
}
} /* if run from scheduler */
/* Clean up */
if (FMimetype) fclose(FMimetype);
magic_close(MagicCookie);
if (DBMime) PQclear(DBMime);
if (pgConn) PQfinish(pgConn);
/* after cleaning up agent, disconnect from the scheduler, this doesn't return */
fo_scheduler_disconnect(0);
return(0);
} /* main() */
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
}
