fo_cleanup.c

Go to the documentation of this file.

/* {{{ Initial comments */
/*
 * $LastChangedDate: 2004-04-01 18:34:17 +0200 (Thu, 01 Apr 2004) $
 * $LastChangedRevision: 50 $
 * $LastChangedBy: ckruse $
 *
 */
/* }}} */

/* {{{ Includes */
#include "config.h"
#include "defines.h"

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>

/* socket includes */
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <sys/un.h>

#include "readline.h"
#include "hashlib.h"
#include "utils.h"
#include "configparser.h"
#include "cfcgi.h"
#include "template.h"
#include "clientlib.h"
#include "readline.h"
/* }}} */

/* {{{ cleanup_deleted_file */
int cleanup_deleted_file(int sock,struct stat *st,t_string *str) {
  FILE *fd;
  u_int64_t *field;
  u_int32_t i,nmem = 0,len;
  u_char buff[512];
  rline_t tsd;
  char *line;
  t_array ary;

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

  array_init(&ary,sizeof(*field),NULL);

  nmem  = st->st_size / sizeof(*field);
  field = fo_alloc(NULL,nmem,sizeof(*field),FO_ALLOC_MALLOC);

  if((fd = fopen(str->content,"r")) == NULL) {
    free(field);
    perror("fopen");
    array_destroy(&ary);
    return EXIT_FAILURE;
  }

  fread(field,sizeof(*field),nmem,fd);
  fclose(fd);

  for(i=0;i<nmem;i++) {
    len = snprintf(buff,512,"STAT THREAD t%lld\n",field[i]);
    writen(sock,buff,len);

    if((line = readline(sock,&tsd)) == NULL) {
      free(field);
      array_destroy(&ary);
      perror("readline");
      return EXIT_FAILURE;
    }

    if(cf_strncmp(line,"404",3) != 0) {
      array_push(&ary,&field[i]);
    }

    free(line);
  }

  if((fd = fopen(str->content,"w")) == NULL) {
    perror("fopen");
    array_destroy(&ary);
    return EXIT_FAILURE;
  }

  fwrite(ary.array,ary.element_size,ary.elements,fd);
  fclose(fd);

  return EXIT_SUCCESS;
}
/* }}} */

/* {{{ compare */
#ifndef DOXYGEN
int compare(t_cf_tree_dataset *a,t_cf_tree_dataset *b) {
  if(*((u_int64_t *)a->key) < *((u_int64_t *)b->key)) return -1;
  if(*((u_int64_t *)a->key) > *((u_int64_t *)b->key)) return 1;

  return 0;
}
#endif
/* }}} */

/* {{{ cleanup_visited_file */
int cleanup_visited_file(int sock,struct stat *st,t_string *str) {
  t_cf_tree tree;
  u_char *line;
  rline_t rsd;
  u_int64_t mid;
  t_cf_tree_dataset data = { NULL, NULL };

  FILE *fd;
  u_int64_t *field;
  u_int32_t i,nmem = 0;

  t_array ary;

  cf_tree_init(&tree,compare,NULL);
  memset(&rsd,0,sizeof(rsd));

  data.data = NULL;

  writen(sock,"GET MIDLIST\n",12);
  line = readline(sock,&rsd);

  if(!line || cf_strncmp(line,"200",3)) {
    if(line) free(line);
    cf_tree_destroy(&tree);
    fprintf(stderr,"server returned not 200\n");
    return EXIT_FAILURE;
  }

  while((line = readline(sock,&rsd)) != NULL) {
    if(*line == '\n') {
      free(line);
      break;
    }

    mid       = strtoull(line+1,NULL,10);
    data.key  = memdup(&mid,sizeof(mid));
    data.data = NULL;

    cf_tree_insert(&tree,NULL,&data);

    free(line);
  }

  nmem  = st->st_size / sizeof(*field);
  field = fo_alloc(NULL,nmem,sizeof(*field),FO_ALLOC_MALLOC);

  if((fd = fopen(str->content,"r")) == NULL) {
    perror("fopen");
    cf_tree_destroy(&tree);
    free(field);
    return EXIT_FAILURE;
  }

  fread(field,sizeof(*field),nmem,fd);
  fclose(fd);

  array_init(&ary,sizeof(*field),NULL);

  for(i=0;i<nmem;i++) {
    data.key  = memdup(&field[i],sizeof(*field));
    data.data = NULL;

    if(cf_tree_find(&tree,tree.root,&data)) {
      array_push(&ary,&field[i]);
    }
  }

  if((fd = fopen(str->content,"w")) == NULL) {
    perror("fopen");
    cf_tree_destroy(&tree);
    array_destroy(&ary);
    free(field);
    return EXIT_FAILURE;
  }
  fwrite(ary.array,ary.element_size,ary.elements,fd);
  fclose(fd);

  free(field);
  cf_tree_destroy(&tree);
  array_destroy(&ary);

  return EXIT_SUCCESS;
}
/* }}} */

/* {{{ cleanup_files */
int cleanup_files(int sock) {
  t_name_value *v = cfg_get_value(&fo_default_conf,"ConfigDirectory");
  DIR *udir = opendir(v->values[0]);
  struct dirent *dp;
  t_string str;
  u_int32_t len = strlen(v->values[0]);
  int ret;
  struct stat st;

  if(!udir) {
    perror("opendir");
    return EXIT_FAILURE;
  }

  str_init(&str);

  while((dp = readdir(udir)) != NULL) {
    /* we don't want . and .. */
    if(*dp->d_name == '.') continue;

    str_chars_append(&str,v->values[0],len);
    str_char_append(&str,'/');
    str_chars_append(&str,dp->d_name,strlen(dp->d_name));

    /* we only want it if it is a directory */
    if(stat(str.content,&st) == -1) {
      str_cleanup(&str);
      continue;
    }
    if(!S_ISDIR(st.st_mode)) {
      str_cleanup(&str);
      continue;
    }

    str_chars_append(&str,"/deleted.dat",12);

    /* we have to check if there is a deleted.dat. If not, it is no valid user directory */
    if(stat(str.content,&st) == -1) {
      str_cleanup(&str);
      continue;
    }

    if((ret = cleanup_deleted_file(sock,&st,&str)) != EXIT_SUCCESS) {
      closedir(udir);
      str_cleanup(&str);
      return ret;
    }

    str.len -= 11;
    str_chars_append(&str,"/visited.dat",12);

    /* we have to check if there is a visited.dat. If not, it is no valid user directory */
    if(stat(str.content,&st) == -1) {
      str_cleanup(&str);
      continue;
    }

    if((ret = cleanup_visited_file(sock,&st,&str)) != EXIT_SUCCESS) {
      closedir(udir);
      str_cleanup(&str);
      return ret;
    }

    str_cleanup(&str);
  }

  closedir(udir);

  return EXIT_SUCCESS;
}
/* }}} */

/* {{{ main */
int main(int argc,char *argv[],char *envp[]) {
  int    sock,ret;
  t_array *cfgfiles;
  u_char *file;
  t_configfile conf,dconf;

  static const u_char *wanted[] = {
    "fo_default","fo_view"
  };

  if((cfgfiles = get_conf_file(wanted,2)) == NULL) {
    fprintf(stderr,"coult not get config files\n");
    return EXIT_FAILURE;
  }

  sock = 0;

  file = *((u_char **)array_element_at(cfgfiles,0));
  cfg_init_file(&dconf,file);
  free(file);

  file = *((u_char **)array_element_at(cfgfiles,1));
  cfg_init_file(&conf,file);
  free(file);

  cfg_register_options(&dconf,default_options);
  cfg_register_options(&conf,fo_view_options);

  if(read_config(&dconf,NULL) != 0 || read_config(&conf,NULL) != 0) {
    fprintf(stderr,"config file error!\n");

    cfg_cleanup_file(&conf);
    cfg_cleanup_file(&dconf);

    return EXIT_FAILURE;
  }

  if((sock = set_us_up_the_socket()) <= 0) {
    perror("sock");
    return EXIT_FAILURE;
  }

  ret = cleanup_files(sock);

  /* cleanup source */
  writen(sock,"QUIT\n",5);
  close(sock);

  cfg_cleanup(&fo_default_conf);
  cfg_cleanup_file(&dconf);
  cfg_cleanup(&fo_view_conf);
  cfg_cleanup_file(&conf);

  array_destroy(cfgfiles);
  free(cfgfiles);

  return ret;
}
/* }}} */

/* eof */

---