utils.c

Go to the documentation of this file.

/*
 SPDX-FileCopyrightText: © 2013 Hewlett-Packard Development Company, L.P.
 SPDX-FileCopyrightText: © 2019 Siemens AG
 
 SPDX-License-Identifier: GPL-2.0-only
*/
#include "maintagent.h"
 
FUNCTION void exitNow(int exitVal)
{
  if (pgConn) PQfinish(pgConn);
  if (dbManager) fo_dbManager_free(dbManager);
 
  if (exitVal) LOG_ERROR("Exiting with status %d", exitVal);
 
  fo_scheduler_disconnect(exitVal);
  exit(exitVal);
} /* ExitNow() */
 
FUNCTION char* strtoupper(char* s)
{
  char* p = s;
  while ((*p = toupper(*p)))
    p++;
  return s;
}
 
FUNCTION void recurseDir(const char* type, char* path, int level)
{
  DIR* dir;
  struct dirent* entry;
  dir = opendir(path);
  if (dir == NULL)
  {
    LOG_ERROR("Unable to open dir: '%s'", path);
    LOG_ERROR("Error: %s", strerror(errno));
    return;
  }
  while ((entry = readdir(dir)) != NULL)
  {
    if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0)
    {
      char nextpath[myBUFSIZ];
      if (level > 0)
      {
        // Have not reached to file yet
        strncpy(nextpath, path, myBUFSIZ - 1);
        strncat(nextpath, "/", myBUFSIZ - 1);
        strncat(nextpath, entry->d_name, myBUFSIZ - 1);
 
        recurseDir(type, nextpath, level - 1);
      }
      else
      {
        // entry is a file
        char delim[] = ".";
        char sha1[41];
        char md5[33];
        long fsize;
        char* ptr;
 
        memset(sha1, '\0', 41);
        memset(md5, '\0', 33);
        strncpy(nextpath, entry->d_name, myBUFSIZ - 1);
        ptr = strtok(nextpath, delim);
        if (ptr == NULL)
        {
          LOG_FATAL("Unable to split path '%s' for pfile.", nextpath);
          exitNow(-105);
        }
        strncpy(sha1, ptr, 40);
        ptr = strtok(NULL, delim);
        strncpy(md5, ptr, 32);
        ptr = strtok(NULL, delim);
        fsize = atol(ptr);
        checkPFileExists(sha1, md5, fsize, type);
      }
    }
  }
  closedir(dir);
}
 
FUNCTION void checkPFileExists(char* sha1, char* md5, long fsize,
                               const char* type)
{
  PGresult* result;
  int countTuples;
  fo_dbManager_PreparedStatement* existsStatement;
  char sql[] =
      "WITH pf AS ("
      "SELECT pfile_pk FROM pfile "
      "WHERE pfile_md5 = $1 AND pfile_sha1 = $2 AND pfile_size = $3) "
      "SELECT 1 AS exists FROM uploadtree INNER JOIN pf "
      "ON pf.pfile_pk = pfile_fk "
      "UNION ALL "
      "SELECT 1 AS exists FROM upload INNER JOIN pf "
      "ON pf.pfile_pk = pfile_fk;";
 
  existsStatement = fo_dbManager_PrepareStamement(dbManager, "checkPfileExists",
                                                  sql, char*, char*, long);
  result = fo_dbManager_ExecPrepared(existsStatement, strtoupper(md5),
                                     strtoupper(sha1), fsize);
  if (fo_checkPQresult(pgConn, result, sql, __FILE__, __LINE__))
  {
    exitNow(-140);
  }
 
  countTuples = PQntuples(result);
  if (countTuples < 1)
  {
    deleteRepoFile(sha1, md5, fsize, type);
    fo_scheduler_heart(1);
  }
  else
  {
    fo_scheduler_heart(0);
  }
  PQclear(result);
}
 
FUNCTION void deleteRepoFile(char* sha1, char* md5, long fsize,
                             const char* type)
{
  char filename[myBUFSIZ];
  char* goldFilePath;
 
  snprintf(filename, myBUFSIZ, "%s.%s.%ld", sha1, md5, fsize);
  goldFilePath = fo_RepMkPath(type, filename);
  unlink(goldFilePath);
  free(goldFilePath);
}