config.c

网络爬虫程序

        {
          char *p, *p2;
          ftp_handshake_info *fhi = (ftp_handshake_info *)ptr->data;

          p = ftp_handshake_info_data_dump(fhi);
          p2 = escape_str(p, "\\\"");
          _free(p);
          p = p2;
          if(*fhi->host)
            snprintf(pom, sizeof(pom),
              "%s \"%s:%hu\" \"%s\"\n",
              params[i].par_entry, fhi->host, fhi->port, p);
          else
            snprintf(pom, sizeof(pom),
              "%s \"\" \"%s\"\n", params[i].par_entry, p);

          _free(p);
          write(fd, pom, strlen(pom));
        }
      }
      break;
    case PARAM_TAGPAT:
      {
        dllist *ptr;
        for(ptr = *((dllist **) params[i].val_adr); ptr; ptr = ptr->next)
        {
          char *t, *a, *u;
          tag_pattern_t *tp = (tag_pattern_t *) ptr->data;

          t = escape_str(tp->tag, "\\\"");
          a = escape_str(tp->attrib, "\\\"");
          u = escape_str(tp->urlp, "\\\"");

          snprintf(pom, sizeof(pom),
            "%s \"%s\" \"%s\" \"%s\"\n", params[i].par_entry, t, a, u);

          _free(t);
          _free(a);
          _free(u);

          write(fd, pom, strlen(pom));
        }
      }
      break;
    }
  }
  return 0;
}

int cfg_dump(const char *filename)
{
  int fd;

  if((fd = open(filename, O_BINARY | O_CREAT | O_WRONLY, 0666)) < 0)
  {
    xperror(filename);
    return -1;
  }

  ftruncate(fd, 0);

  cfg_dump_fd(fd);

  close(fd);
  return 0;
}

int cfg_load_pref(void)
{
  bufio *fd;
  char filename[PATH_MAX];

  snprintf(filename, sizeof(filename), "%s/.pavuk_prefs", cfg.path_to_home);

  if(!(fd = bufio_open(filename, O_BINARY | O_RDONLY)))
  {
    return -1;
  }

  cfg_set_all_to_default();

  cfg_load_fd(fd);

  bufio_close(fd);

  return 0;
}

int cfg_dump_pref(void)
{
  int fd;
  char filename[PATH_MAX];

  snprintf(filename, sizeof(filename), "%s/.pavuk_prefs", cfg.path_to_home);

  if((fd = open(filename, O_BINARY | O_CREAT | O_WRONLY, 0666)) < 0)
  {
    xperror(filename);
    return -1;
  }

  ftruncate(fd, 0);

  cfg_dump_fd(fd);

  close(fd);
  return 0;
}

int cfg_dump_cmd(const char *filename)
{
  int fd;
  int rv;

  if((fd = open(filename, O_BINARY | O_CREAT | O_WRONLY, 0666)) < 0)
  {
    xperror(filename);
    return -1;
  }

  rv = cfg_dump_cmd_fd(fd);

  close(fd);

  return rv;
}

int cfg_dump_cmd_fd(int fd)
{
  int i, j;
  char pom[8192];
  char pom2[20];
  char **pl;

  ftruncate(fd, 0);

  write(fd, cfg.prg_path, strlen(cfg.prg_path));

  write(fd, " ", 1);

  if(cfg.request)
  {
    dllist *dptr;

    for(dptr = cfg.request; dptr; dptr = dptr->next)
    {
      url_info *ui = (url_info *) dptr->data;

      if(ui->type == URLI_NORMAL && !ui->localname)
      {
        write(fd, " '", 2);
        write(fd, ui->urlstr, strlen(ui->urlstr));
        write(fd, "' ", 2);
      }
    }
  }

  for(i = 0; i < NUM_ELEM(params); i++)
  {
    if(params[i].type & PARAM_UNSUPPORTED)
      continue;
    if(params[i].type & PARAM_FOREIGN)
      continue;
    if(!params[i].long_cmd)
      continue;

    if(!params[i].par_entry &&
      (params[i].type != PARAM_PBOOL) && (params[i].type != PARAM_NBOOL))
      continue;

    switch (params[i].type)
    {
    case PARAM_NUM:
      snprintf(pom, sizeof(pom), " -%s=%ld ", params[i].long_cmd,
        *((long *) params[i].val_adr));
      write(fd, pom, strlen(pom));
      break;
    case PARAM_NBOOL:
      if(!*((bool_t *) params[i].val_adr))
      {
        write(fd, " -", 2);
        write(fd, params[i].long_cmd, strlen(params[i].long_cmd));
        write(fd, " ", 1);
      }
      break;
    case PARAM_PBOOL:
      if(*((bool_t *) params[i].val_adr))
      {
        write(fd, " -", 2);
        write(fd, params[i].long_cmd, strlen(params[i].long_cmd));
        write(fd, " ", 1);
      }
      break;
    case PARAM_PORT_RANGE:
      if(*((long *) params[i].val_adr) >= 0)
      {
        snprintf(pom, sizeof(pom), " -%s=%ld:%ld ", params[i].long_cmd,
          *((long *) params[i].val_adr), *((long *) params[i].mval_adr));
        write(fd, pom, strlen(pom));
      }
      break;
    case PARAM_PATH:
    case PARAM_STR:
    case PARAM_PASS:
      if(*((char **) params[i].val_adr))
      {
        snprintf(pom, sizeof(pom), " -%s '%s' ", params[i].long_cmd,
          *((char **) params[i].val_adr));
        write(fd, pom, strlen(pom));
      }
      break;
    case PARAM_STRLIST:
      if(!params[i].mval_adr || (params[i].mval_adr &&
          (*((bool_t *) params[i].mval_adr) ==
            (bool_t) (long) params[i].mdefault_val)))
      {
        pl = *((char ***) params[i].val_adr);
        if(pl && pl[0])
        {
          snprintf(pom, sizeof(pom), " -%s '%s", params[i].long_cmd, pl[0]);
          write(fd, pom, strlen(pom));

          j = 1;
          while(pl[j])
          {
            write(fd, ",", 1);
            write(fd, pl[j], strlen(pl[j]));
            j++;
          }
          write(fd, "' ", 2);
        }
      }
      break;
    case PARAM_CONN:
      if(*((char **) params[i].val_adr))
      {
        snprintf(pom, sizeof(pom), "-%s %s:%hu ", params[i].long_cmd,
          *((char **) params[i].val_adr), *((int *) params[i].mval_adr));
        write(fd, pom, strlen(pom));
      }
      break;
    case PARAM_AUTHSCH:
      snprintf(pom, sizeof(pom), " -%s %s ", params[i].long_cmd,
        http_auths[*((long *) params[i].val_adr)].name);
      write(fd, pom, strlen(pom));
      break;
    case PARAM_MODE:
      snprintf(pom, sizeof(pom), " -%s %s ", params[i].long_cmd,
        mode_get_str(cfg.mode));
      write(fd, pom, strlen(pom));
      break;
    case PARAM_TIME:
      if(*((time_t *) params[i].val_adr))
      {
        LOCK_TIME;
        strftime(pom2, sizeof(pom2), "%Y.%m.%d.%H:%M",
          localtime((time_t *) params[i].val_adr));
        UNLOCK_TIME;
        snprintf(pom, sizeof(pom), " -%s %s ", params[i].long_cmd, pom2);
        write(fd, pom, strlen(pom));
      }
      break;
    case PARAM_HTMLTAG:
      {
        int x, y;
        bool_t first = TRUE;

        snprintf(pom, sizeof(pom), " -%s '", params[i].long_cmd);
        for(x = 0; x < html_link_tags_num(); x++)
        {
          for(y = 0; html_link_tags[x].attribs[y].attrib; y++)
          {
            if(!(html_link_tags[x].attribs[y].stat & LINK_DISABLED) ==
              !(params[i].default_val))
            {
              if(!first)
              {
                strncat(pom, ";", sizeof(pom) - strlen(pom));
                pom[sizeof(pom) - 1] = '\0';
              }
              strncat(pom, html_link_tags[x].tag, sizeof(pom) - strlen(pom));
              pom[sizeof(pom) - 1] = '\0';
              strncat(pom, ",", sizeof(pom) - strlen(pom));
              pom[sizeof(pom) - 1] = '\0';
              strncat(pom, html_link_tags[x].attribs[y].attrib,
                sizeof(pom) - strlen(pom));
              pom[sizeof(pom) - 1] = '\0';
              first = FALSE;
            }
          }
        }
        strncat(pom, "' ", sizeof(pom) - strlen(pom));
        pom[sizeof(pom) - 1] = '\0';
        if(!first)
          write(fd, pom, strlen(pom));
      }
      break;
    case PARAM_TWO_QSTR:
      if(*((char **) params[i].val_adr))
      {
        snprintf(pom, sizeof(pom), " -%s '%s' '%s' ", params[i].long_cmd,
          *((char **) params[i].val_adr), *((char **) params[i].mval_adr));
        write(fd, pom, strlen(pom));
      }
      break;
    case PARAM_DOUBLE:
      snprintf(pom, sizeof(pom), " -%s=%.3f ", params[i].long_cmd,
        *((double *) params[i].val_adr));
      write(fd, pom, strlen(pom));
      break;
    case PARAM_LFNAME:
      {
        dllist *pdl = cfg.lfnames;
        while(pdl)
        {
          lfname *lfnm = (lfname *)pdl->data;

          snprintf(pom, sizeof(pom), " -%s \'%s\' \'%s\' \'%s\' ",
            params[i].long_cmd, (lfnm->type == LFNAME_FNMATCH) ? "F" : "R",
            lfnm->matchstr, lfnm->transstr);
          write(fd, pom, strlen(pom));

          pdl = pdl->next;
        }
      }
      break;
    case PARAM_RE:
#ifdef HAVE_REGEX
      {
        dllist *ptr = *((dllist **) params[i].val_adr);
        while(ptr)
        {
          re_entry *ree = (re_entry *)ptr->data;

          snprintf(pom, sizeof(pom), " -%s \'%s\' ", params[i].long_cmd,
            ree->pattern);
          write(fd, pom, strlen(pom));

          ptr = ptr->next;
        }
      }
#endif
      break;
    case PARAM_USTRAT:
      snprintf(pom, sizeof(pom), " -%s=%s ", params[i].long_cmd,
        get_strategie_str(*(strategie *) params[i].val_adr));
      write(fd, pom, strlen(pom));
      break;
    case PARAM_SSLVER:
      snprintf(pom, sizeof(pom), " -%s=%s ", params[i].long_cmd,
        get_ssl_version_str(*(int *) params[i].val_adr));
      write(fd, pom, strlen(pom));
      break;
    case PARAM_HTTPHDR:
      {
        dllist *ptr = *((dllist **) params[i].val_adr);
        while(ptr)
        {
          httphdr *hr = (httphdr *) ptr->data;

          snprintf(pom, sizeof(pom), " -%s \"%s%s %s\" ", params[i].long_cmd,
            hr->all ? "+" : "", hr->name, hr->val);
          write(fd, pom, strlen(pom));

          ptr = ptr->next;
        }
      }
      break;
    case PARAM_DEBUGL:
#ifdef DEBUG
      {
        char strbuf[1024];
        debug_level_construct(*((int *) params[i].val_adr), strbuf);
        snprintf(pom, sizeof(pom), " -%s \'%s\' ", params[i].long_cmd,
          strbuf);
        write(fd, pom, strlen(pom));
      }
#endif
      break;
    case PARAM_REQUEST:
      {
        dllist *ptr = *((dllist **) params[i].val_adr);
        while(ptr)
        {
          url_info *ui = (url_info *) ptr->data;

          if(ui->type != URLI_NORMAL || ui->localname)
          {
            char *p = url_info_dump(ui);
            snprintf(pom, sizeof(pom), " -%s \'%s\' ", params[i].long_cmd, p);
            _free(p);
            write(fd, pom, strlen(pom));
          }

          ptr = ptr->next;
        }
      }
      break;
    case PARAM_TRANSPARENT:
      {
        http_proxy *pr = *((http_proxy **) params[i].val_adr);
        snprintf(pom, sizeof(pom), " -%s=%s:%d ", params[i].long_cmd,
          pr->addr, pr->port);
        write(fd, pom, strlen(pom));
      }
      break;
    case PARAM_PROXY:
      {
        dllist *ptr = *((dllist **) params[i].val_adr);
        while(ptr)
        {
          http_proxy *pr = (http_proxy *) ptr->data;
          snprintf(pom, sizeof(pom), " -%s=%s:%hu ", params[i].long_cmd,
            pr->addr, pr->port);
          write(fd, pom, strlen(pom));

          ptr = ptr->next;
        }
      }
      break;
    case PARAM_FUNC:
      break;
    case PARAM_JSTRANS:
#ifdef HAVE_REGEX
      {
        dllist *ptr;
        for(ptr = cfg.js_transform; ptr; ptr = ptr->next)
        {
          js_transform_t *jt = (js_transform_t *) ptr->data;
          if(jt->type != (long) params[i].mdefault_val)
            continue;

          snprintf(pom, sizeof(pom), " -%s \'%s\' \'%s\' \'%s\' \'%s\' ",
            params[i].long_cmd, jt->re->pattern, jt->transform, jt->tag,
            jt->attrib);
          write(fd, pom, strlen(pom));
        }
      }
#endif
      break;
    case PARAM_NUMLIST:
      if(!params[i].mval_adr || (params[i].mval_adr &&
          (*((bool_t *) params[i].mval_adr) ==
            (bool_t) (long) params[i].mdefault_val)))
      {
        dllist *ptr = *((dllist **) params[i].val_adr);
        if(ptr)
        {
          snprintf(pom, sizeof(pom), "-%s %ld", params[i].long_cmd,
            (long) ptr->data);
          write(fd, pom, strlen(pom));

          j = 1;
          for(; ptr; ptr = ptr->next)
          {
            snprintf(pom, sizeof(pom), ",%ld", (long) ptr->data);
            write(fd, pom, strlen(pom));
          }
          write(fd, " ", 1);
        }
      }
      break;
    case PARAM_FTPHS:
      {
        dllist *ptr;
        for(ptr = *((dllist **) params[i].val_adr); ptr; ptr = ptr->next)
        {
          char *p;
          ftp_handshake_info *fhi = (ftp_handshake_info *) ptr->data;

          p = ftp_handshake_info_data_dump(fhi);

          if(*fhi->host)
            snprintf(pom, sizeof(pom),
              "-%s \"%s:%hu\" \"%s\" ",
              params[i].long_cmd, fhi->host, fhi->port, p);
          else
            snprintf(pom, sizeof(pom),
              "-%s \"\" \"%s\" ", params[i].long_cmd, p);
          _free(p);
          write(fd, pom, strlen(pom));
        }
      }
      break;
    case PARAM_TAGPAT:
      {
        dllist *ptr;
        for(ptr = *((dllist **) params[i].val_adr); ptr; ptr = ptr->next)
        {
          tag_pattern_t *tp = (tag_pattern_t *) ptr->data;

          snprintf(pom, sizeof(pom),
            "-%s \"%s\" \"%s\" \"%s\" ",
            params[i].long_cmd, tp->tag, tp->attrib, tp->urlp);

          write(fd, pom, strlen(pom));
        }
      }