Exemplo n.º 1
0
static int read_memcmp(const PureDB * const db, const puredb_u32_t offset,
                       const unsigned char *str, const puredb_u32_t len)
{
    unsigned char *mapoffsetbuf;
    int cmp;

#ifdef USE_MAPPED_IO
    if (db->map != NULL) {
        return memcmp(db->map + offset, str, (size_t) len) != 0;
    }
#endif
    if ((mapoffsetbuf = (unsigned char *) ALLOCA(len)) == NULL) {
        return -2;
    }
    if (lseek(db->fd, offset, SEEK_SET) == (off_t) -1) {
        err:
        ALLOCA_FREE(mapoffsetbuf);
        return -2;
    }
    if (safe_read(db->fd, mapoffsetbuf, (size_t) len) != (ssize_t) len) {
        goto err;
    }
    cmp = memcmp(mapoffsetbuf, str, (size_t) len) != 0;
    ALLOCA_FREE(mapoffsetbuf);

    return cmp;
}
Exemplo n.º 2
0
static LDAPMessage *pw_ldap_uid_search(LDAP * const ld,
                                       const char *uid,
                                       char *attrs[])
{
    char *alloca_filter;
    size_t uid_size;
    size_t filter_size;
    int rc;
    LDAPMessage *res;

    if (uid == NULL || *uid == 0) {
        return NULL;
    }
    uid_size = strlen(uid);
    if (uid_size > MAX_LDAP_UID_LENGTH) {
        return NULL;
    }
    filter_size = strlen(ldap_filter) + uid_size + (size_t) 1U;
    if ((alloca_filter = ALLOCA(filter_size)) == NULL) {
        return NULL;
    }
    if (SNCHECK(snprintf(alloca_filter, filter_size, ldap_filter, uid),
        filter_size)) {
        ALLOCA_FREE(alloca_filter);
        return NULL;
    }
    rc = ldap_search_s(ld, base, LDAP_SCOPE_SUBTREE,
                       alloca_filter, attrs, 0, &res);
    ALLOCA_FREE(alloca_filter);
    if (rc != LDAP_SUCCESS) {
        return NULL;
    }

    return res;
}
Exemplo n.º 3
0
int privsep_recvfd(const int psfd)
{
    char *buf;
    int *fdptr;    
    struct cmsghdr *cmsg;
    struct msghdr msg;
    struct iovec vec;
    const size_t sizeof_buf = CMSG_SPACE(sizeof *fdptr);
    size_t sizeof_buf_ = sizeof_buf;
    PrivSepCmd fodder = 0;
    ssize_t received;
    
    if (sizeof_buf_ < sizeof *cmsg) {
        sizeof_buf_ = sizeof *cmsg;
    }
    if ((buf = ALLOCA(sizeof_buf_)) == NULL) {
        return -1;
    }
    memset(&msg, 0, sizeof msg);
    vec.iov_base = (void *) &fodder;
    vec.iov_len = sizeof fodder;
    msg.msg_name = NULL;
    msg.msg_namelen = (socklen_t) 0;
    msg.msg_iov = &vec;
    msg.msg_iovlen = (size_t) 1U;
    msg.msg_control = buf;
    msg.msg_controllen = sizeof_buf;
    msg.msg_flags = 0;
    if ((cmsg = CMSG_FIRSTHDR(&msg)) == NULL ||
        (fdptr = (int *) CMSG_DATA(cmsg)) == NULL) {    
        ALLOCA_FREE(buf);
        return -1;    
    }    
    *fdptr = -1;
    while ((received = recvmsg(psfd, &msg, 0)) == (ssize_t) -1 && 
           errno == EINTR);
# if defined(MSG_TRUNC) && defined(MSG_CTRUNC)        
    if ((msg.msg_flags & MSG_TRUNC) || (msg.msg_flags & MSG_CTRUNC)) {
        ALLOCA_FREE(buf);
        return -1;        
    }
# endif
    if (received != (ssize_t) sizeof fodder ||
        fodder != PRIVSEPCMD_ANSWER_FD ||
        (cmsg = CMSG_FIRSTHDR(&msg)) == NULL ||
        (fdptr = (int *) CMSG_DATA(cmsg)) == NULL) {
        ALLOCA_FREE(buf);
        return -1;
    }
    return *fdptr;
}
Exemplo n.º 4
0
int privsep_sendfd(const int psfd, const int fd)
{
    char *buf;
    int *fdptr;
    struct cmsghdr *cmsg;    
    struct msghdr msg;
    struct iovec vec;
    const size_t sizeof_buf = CMSG_SPACE(sizeof *fdptr);
    size_t sizeof_buf_ = sizeof_buf;
    PrivSepCmd fodder = PRIVSEPCMD_ANSWER_FD;
    ssize_t sent;
    
    if (sizeof_buf_ < sizeof *cmsg) {
        sizeof_buf_ = sizeof *cmsg;
    }
    if ((buf = ALLOCA(sizeof_buf_)) == NULL) {
        return -1;
    }
    memset(&msg, 0, sizeof msg);
    vec.iov_base = (void *) &fodder;
    vec.iov_len = sizeof fodder;
    msg.msg_name = NULL;
    msg.msg_namelen = (socklen_t) 0;
    msg.msg_iov = &vec;
    msg.msg_iovlen = (size_t) 1U;
    msg.msg_control = buf;
    msg.msg_controllen = sizeof_buf;
    msg.msg_flags = 0;
    if ((cmsg = CMSG_FIRSTHDR(&msg)) == NULL) {
        ALLOCA_FREE(buf);
        return -1;
    }
    cmsg->cmsg_len = CMSG_LEN(sizeof fd);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    if ((fdptr = (int *) CMSG_DATA(cmsg)) == NULL) {
        ALLOCA_FREE(buf);    
        return -1;
    }
    *fdptr = fd;
    msg.msg_controllen = cmsg->cmsg_len;
    while ((sent = sendmsg(psfd, &msg, 0)) == (ssize_t) -1 && errno == EINTR);
    ALLOCA_FREE(buf);    
    if (sent != (ssize_t) sizeof fodder) {
        return -1;
    }
    return 0;
}    
Exemplo n.º 5
0
static void
do_arcfour_random(struct randomness *r, UINT32 length, UINT8 *dst)
{
#if ALLOCA_68K_BUG
  ALLOCA_START(alloca_ref);
#endif
  CAST(arcfour_random, self, r);
  
  self->staging_count += RANDOM_POLL_FAST(self->super.poller, self->staging_area);

  if (self->staging_count > STAGE_THRESHOLD)
    {
      /* Pour the collected randomness into the pool */
      UINT8 *buf = alloca(self->staging_area->hash_size);

      verbose("do_arcfour_random: Pouring staging area into pool.\n");
      
      /* Get some data out of the pool, in order to keep any entropy
       * there. */
      arcfour_stream(&self->pool, self->staging_area->hash_size, buf);

      HASH_UPDATE(self->staging_area, self->staging_area->hash_size, buf);
      
      HASH_DIGEST(self->staging_area, buf);
      arcfour_set_key(&self->pool, self->staging_area->hash_size, buf);

      self->staging_count = 0;
    }

  arcfour_stream(&self->pool, length, dst);
#if ALLOCA_68K_BUG
  ALLOCA_FREE(alloca_ref);
#endif
}
Exemplo n.º 6
0
static int client_process_delete(Client * const client)
{
    char *store_file;
    char *store_file_pnt;
    size_t sizeof_store_file;

    logfile(LOG_DEBUG, _("client_process_delete, fd #%d"), client->client_fd);
    if (client->offset_read_buf < (size_t) 6U) {
        return -1;
    }
    sizeof_store_file = (sizeof "/") - (size_t) 1U +
        client->key_len + (size_t) 1U;
    if ((store_file = ALLOCA(sizeof_store_file)) == NULL) {
        logfile(LOG_WARNING, _("Out of stack for ALLOCA"));
        return -1;
    }
    store_file_pnt = store_file;
    *store_file_pnt++ = '/';
    if (validate_key(client->read_buf + (size_t) 5U, client->key_len) != 0) {
        ALLOCA_FREE(store_file);
        logfile(LOG_WARNING, _("Invalid key name"));
        return -1;
    }
    memcpy(store_file_pnt, client->read_buf + (size_t) 5U, client->key_len);
    store_file_pnt += client->key_len;
    *store_file_pnt = 0;
    logfile(LOG_DEBUG, _("Deleting [%s]"), store_file);
    if (unlink(store_file) != 0) {
        logfile(LOG_INFO, _("Unable to delete [%s]: [%s]"), store_file,
                strerror(errno));
        ALLOCA_FREE(store_file);
        return -1;
    }
    if ((client->returncode_bufev =
         bufferevent_new(client->client_fd,
                         returncode_bufferev_read_cb,
                         returncode_bufferev_write_cb,
                         returncode_bufferev_error_cb,
                         client)) == NULL) {
        logfile(LOG_WARNING, _("Unable to create a bufferevent for fd #%d"),
                client->client_fd);
    }
    (void) bufferevent_write(client->returncode_bufev, (void *) RETURNCODE_OK,
                             sizeof RETURNCODE_OK - (size_t) 1U);

    return 0;
}
Exemplo n.º 7
0
void ftpwho_unlinksbfile(const pid_t pid)
{
    size_t sbfile_size;
    char *sbfile;
    
    sbfile_size = sizeof SCOREBOARD_PATH - 1U + 1U +
        sizeof SCOREBOARD_PREFIX - 1U + 8U + 1U;
        
    if ((sbfile = ALLOCA(sbfile_size)) == NULL) {
        return;
    }
    if (SNCHECK(snprintf(sbfile, sbfile_size, 
                         SCOREBOARD_PATH "/" SCOREBOARD_PREFIX "%08lu",
                         (unsigned long) pid), sbfile_size)) {
        ALLOCA_FREE(sbfile);
        return;
    }    
    (void) unlink(sbfile);
    ALLOCA_FREE(sbfile);
}
Exemplo n.º 8
0
static int altlog_writexfer_w3c(const int upload,
                                const char * const filename,
                                const off_t size,
                                const double duration)
{
    /*
     * <date> <time> <ip> "[]sent" <file> "226" <user>
     * date time c-ip cs-method cs-uri-stem sc-status cs-username
     */

    struct tm *tm;
    struct tm gmt;
    const char *host_ = *host != 0 ? host : "-";
    const char *account_ = *account != 0 ? account : "-";
    char *alloca_line;
    char *quoted_filename;
    time_t now;
    size_t line_size;

    (void) duration;
    if ((now = time(NULL)) == (time_t) -1 ||
        (tm = localtime(&now)) == NULL ||
        tm->tm_mon > 11 || tm->tm_mon < 0) {
        return -1;
    }
    gmt = *gmtime(&now);
    if ((quoted_filename = urlencode(filename)) == NULL) {
        return -1;
    }
    line_size = (sizeof "13-04-1975 12:34:56 " - 1U) +
        strlen(host_) + 1U + (sizeof "[]created" - 1U) + 1U +
        strlen(quoted_filename) + 1U + (sizeof "226" - 1U) +
        strlen(account_) + 1U + 42U + 1U /* \n */ + 1U;

    if ((alloca_line = ALLOCA(line_size)) == NULL) {
        return -1;
    }
    if (!SNCHECK(snprintf(alloca_line, line_size,
                          "%d-%02d-%02d %02d:%02d:%02d %s []%s %s 226 %s %llu\n",
                          gmt.tm_year + 1900, gmt.tm_mon + 1, gmt.tm_mday,
                          gmt.tm_hour, gmt.tm_min, gmt.tm_sec,
                          host_, (upload != 0 ? "created" : "sent"),
                          quoted_filename,
                          account, (unsigned long long) size), line_size)) {
        altlog_write(alloca_line);
    }
    if (quoted_filename != filename) {
        free(quoted_filename);
    }
    ALLOCA_FREE(alloca_line);

    return 0;
}
Exemplo n.º 9
0
static void
do_arcfour_random_slow(struct randomness *r, UINT32 length, UINT8 *dst)
{
#if ALLOCA_68K_BUG
  ALLOCA_START(alloca_ref);
#endif
  CAST(arcfour_random, self, r);

  unsigned count = RANDOM_POLL_SLOW(self->super.poller, self->staging_area);

  debug("arcfour_random: entropy estimate for initialization: %i bits.\n",
	count);
  
  if (count < STAGE_THRESHOLD)
    {
      const struct exception low_entropy =
	STATIC_EXCEPTION(EXC_RANDOMNESS_LOW_ENTROPY,
			 "Could not get enough entropy from the environment.");
      EXCEPTION_RAISE(self->e, &low_entropy);
    }
  else
    self->super.super.quality = 1;
  
  {
    /* Initialize the pool. */
    UINT8 *buf = alloca(self->staging_area->hash_size);
    
    verbose("do_arcfour_random_slow: Initalizing randomness pool.\n");
    HASH_DIGEST(self->staging_area, buf);
    arcfour_set_key(&self->pool, self->staging_area->hash_size, buf);

    self->staging_count = 0;
  }
  
  self->super.super.random = do_arcfour_random;

  arcfour_stream(&self->pool, length, dst);
#if ALLOCA_68K_BUG
  ALLOCA_FREE(alloca_ref);
#endif
}
Exemplo n.º 10
0
Arquivo: rsa.c Projeto: macssh/macssh
static void
pkcs1_encode(mpz_t m,
	     struct rsa_algorithm *params,
	     UINT32 length,
	     UINT32 msg_length,
	     const UINT8 *msg)
{
#if ALLOCA_68K_BUG
  ALLOCA_START(alloca_ref);
#endif
  UINT8 *em = alloca(length);
  unsigned i = length;
  
  struct hash_instance *h = MAKE_HASH(params->hash);
  HASH_UPDATE(h, msg_length, msg);

  assert(i >= h->hash_size);
  i -= h->hash_size;

  HASH_DIGEST(h, em + i);
  KILL(h);

  assert(i >= params->prefix_length);
  i -= params->prefix_length;

  memcpy(em + i, params->prefix, params->prefix_length);

  assert(i);
  em[--i] = 0;

  assert(i >= 9);
  em[0] = 1;
  memset(em + 1, 0xff, i - 1);
  
  bignum_parse_u(m, length, em);

  debug("pkcs1_encode: m = %xn\n", m);
#if ALLOCA_68K_BUG
  ALLOCA_FREE(alloca_ref);
#endif
}
Exemplo n.º 11
0
static int altlog_writexfer_stats(const int upload,
                                  const char * const filename,
                                  const off_t size,
                                  const double duration)
{
    /*
     * <date> <start.pid> <user> <ip> <u/d> <size> <duration> <file>
     */

    const char *host_ = *host != 0 ? host : "-";
    const char *account_ = *account != 0 ? account : "-";
    char *alloca_line;
    size_t line_size;

    line_size = 16U /* now */ + 1U + 16U /* start */ + 1U /* . */ +
        16U /* pid */ + 1U + strlen(account_) + 1U + strlen(host_) + 1U +
        1U /* U/D */ + 1U + 20U /* size */ + 1U + 16U /* duration */ +
        strlen(filename) + 1U /* \n */ + 1U;
    if ((alloca_line = ALLOCA(line_size)) == NULL) {
        return -1;
    }
    if (!SNCHECK(snprintf(alloca_line, line_size,
                          "%llu %llx.%lx %s %s %c %llu %lu %s\n",
                          (unsigned long long) time(NULL),
                          (unsigned long long) session_start_time,
                          (unsigned long) getpid(),
                          account_, host_,
                          upload != 0 ? 'U' : 'D',
                          (unsigned long long) size,
                          (unsigned long) (duration + 0.5),
                          filename), line_size)) {
        altlog_write(alloca_line);
    }

    ALLOCA_FREE(alloca_line);

    return 0;
}
Exemplo n.º 12
0
int altlog_write_w3c_header(void)
{
    time_t now;
    struct tm *tm;
    struct tm gmt;
    char *alloca_line;
    size_t line_size;

    if ((now = time(NULL)) == (time_t) -1 ||
        (tm = localtime(&now)) == NULL ||
        tm->tm_mon > 11 || tm->tm_mon < 0) {
        return -1;
    }
    gmt = *gmtime(&now);
    line_size = sizeof "#Date: 001975-04-13 12:34:56\n";   /* be year-999999 compliant :) */
    if ((alloca_line = ALLOCA(line_size)) == NULL) {
        return -1;
    }

    altlog_write("#Software: Pure-FTPd " VERSION "\n");
    altlog_write("#Version: 1.0\n");

    if (!SNCHECK(snprintf(alloca_line, line_size,
                          "#Date: %04d-%02d-%02d %02d:%02d:%02d\n",
                          gmt.tm_year + 1900, gmt.tm_mon + 1, gmt.tm_mday,
                          gmt.tm_hour, gmt.tm_min, gmt.tm_sec),
                          line_size)) {
        altlog_write(alloca_line);
    }

    altlog_write("#Fields: date time c-ip cs-method cs-uri-stem sc-status cs-username sc-bytes\n");

    ALLOCA_FREE(alloca_line);

    return 0;
}
Exemplo n.º 13
0
int fill_mac_address(void)
{
    int s;

    if ((s = socket(HWINFO_DOMAIN, HWINFO_TYPE, 0)) == -1) {
        logfile(LOG_ERR, _("Unable to open raw device: [%s]"),
                strerror(errno));
        return -1;
    }
#ifdef SIOCGIFHWADDR
    {
        struct ifreq ifr;
        
        if (strlen(interface) >= sizeof ifr.ifr_name) {
            logfile(LOG_ERR, _("Interface name too long"));
            return -1;
        }
        strncpy(ifr.ifr_name, interface, sizeof ifr.ifr_name);
        if (ioctl(s, SIOCGIFHWADDR, &ifr) != 0) {
            logfile(LOG_ERR,
                    _("Unable to get hardware info about an interface: %s"),
                    strerror(errno));
            (void) close(s);
            return -1;
        }
        switch (ifr.ifr_hwaddr.sa_family) {
        case ARPHRD_ETHER:
        case ARPHRD_IEEE802:
            break;
        default:
            logfile(LOG_ERR, _("Unknown hardware type [%u]"),
                    (unsigned int) ifr.ifr_hwaddr.sa_family);
        }
        memcpy(hwaddr, &ifr.ifr_hwaddr.sa_data, sizeof hwaddr);
    }
#elif defined(HAVE_GETIFADDRS)
    {   
        struct ifaddrs *ifas;
        struct ifaddrs *ifa;
        struct sockaddr_dl *sadl;
        struct ether_addr *ea;
        
        if (getifaddrs(&ifas) != 0) {
            logfile(LOG_ERR, _("Unable to get interface address: %s"),
                    strerror(errno));
            return -1;
        }
        ifa = ifas;
        while (ifa != NULL) {
            if (strcmp(ifa->ifa_name, interface) == 0 &&
                ifa->ifa_addr->sa_family == AF_LINK) {
                sadl = (struct sockaddr_dl *) ifa->ifa_addr;
                if (sadl == NULL || sadl->sdl_type != IFT_ETHER ||
                    sadl->sdl_alen <= 0) {
                    logfile(LOG_ERR,
                            _("Invalid media / hardware address for [%s]"),
                            interface);
                    return -1;
                }
                ea = (struct ether_addr *) LLADDR(sadl);
                memcpy(hwaddr, ea, sizeof hwaddr);
                
                return 0;
            }
            ifa = ifa->ifa_next;
        }
        return -1;
    }
#elif defined(SIOCGLIFNUM)
    {
        struct lifconf lifc;
        struct lifnum lifn;
        struct lifreq *lifr;
        caddr_t *lifrspace;
        struct arpreq arpreq;
        
        lifn.lifn_flags = 0;
        lifn.lifn_family = AF_INET;
        if (ioctl(s, SIOCGLIFNUM, &lifn) < 0) {
            logfile(LOG_ERR, _("ioctl SIOCGLIFNUM error"));
            return -1;
        }
        if (lifn.lifn_count <= 0) {
            logfile(LOG_ERR, _("No interface found"));
            return -1;            
        }
        lifc.lifc_family = lifn.lifn_family;
        lifc.lifc_len = lifn.lifn_count * sizeof *lifr;
        lifrspace = ALLOCA(lifc.lifc_len);
        lifc.lifc_buf = (caddr_t) lifrspace;
        if (ioctl(s, SIOCGLIFCONF, &lifc) < 0) {
            logfile(LOG_ERR, _("ioctl SIOCGLIFCONF error"));
            ALLOCA_FREE(lifrspace);
            return -1;
        }        
        lifr = lifc.lifc_req;
	for(;;) {
	    if (lifn.lifn_count <= 0) {
		logfile(LOG_ERR, _("Interface [%s] not found"), interface);
		ALLOCA_FREE(lifrspace);
		return -1;            		
	    }
	    lifn.lifn_count--;
            if (strcmp(lifr->lifr_name, interface) == 0) {
                break;
            }	   
            lifr++;
        }
        memcpy(&arpreq.arp_pa, &lifr->lifr_addr, sizeof arpreq.arp_pa);
        ALLOCA_FREE(lifrspace);
        if (ioctl(s, SIOCGARP, &arpreq) != 0) {
            logfile(LOG_ERR, _("Unable to get hardware info about [%s]"),
                    interface);
            return -1;
        }       
        memcpy(hwaddr, &arpreq.arp_ha.sa_data, sizeof hwaddr);
    }
#endif
    
    (void) close(s);    
    
    return 0;
}
Exemplo n.º 14
0
static int client_process_store(Client * const client)
{
    char *store_file;
    char *store_file_tmp;
    char *store_file_pnt;
    char *store_file_tmp_pnt;
    size_t sizeof_store_file;
    size_t sizeof_store_file_tmp;

    logfile(LOG_DEBUG, _("client_process_store, fd #%d"), client->client_fd);
    if (client->offset_read_buf < (size_t) 10U) {
        return -1;
    }
    sizeof_store_file = (sizeof "/") - (size_t) 1U +
        client->key_len + (size_t) 1U;
    if ((store_file = ALLOCA(sizeof_store_file)) == NULL) {
        logfile(LOG_ERR, _("Out of stack for ALLOCA"));
        return -1;
    }
    store_file_pnt = store_file;
    *store_file_pnt++ = '/';
    if (validate_key(client->read_buf + (size_t) 9U, client->key_len) != 0) {
        ALLOCA_FREE(store_file);
        logfile(LOG_WARNING, _("Invalid key name"));
        return -1;
    }
    memcpy(store_file_pnt, client->read_buf + (size_t) 9U, client->key_len);
    store_file_pnt += client->key_len;
    *store_file_pnt = 0;

    sizeof_store_file_tmp = (sizeof "/") - (size_t) 1U +
        sizeof STOREFILE_TMP_PREFIX - (size_t) 1U +
        client->key_len + (size_t) 1U;
    if ((store_file_tmp = ALLOCA(sizeof_store_file_tmp)) == NULL) {
        logfile(LOG_ERR, _("Out of stack for ALLOCA"));
        ALLOCA_FREE(store_file);
        return -1;
    }
    store_file_tmp_pnt = store_file_tmp;
    *store_file_tmp_pnt++ = '/';
    memcpy(store_file_tmp_pnt, STOREFILE_TMP_PREFIX,
           sizeof STOREFILE_TMP_PREFIX - (size_t) 1U);
    store_file_tmp_pnt += sizeof STOREFILE_TMP_PREFIX - (size_t) 1U;
    memcpy(store_file_tmp_pnt,
           client->read_buf + (size_t) 9U, client->key_len);
    store_file_tmp_pnt += client->key_len;
    *store_file_tmp_pnt = 0;

    logfile(LOG_DEBUG, _("Creating [%s]"), store_file_tmp);
    if ((client->write_fd =
         open(store_file_tmp, O_CREAT | O_NOFOLLOW | O_WRONLY | O_TRUNC,
              (mode_t) 0600)) == -1) {
        logfile(LOG_WARNING, _("Unable to create [%s]: [%s]"), store_file,
                strerror(errno));
        ALLOCA_FREE(store_file);
        ALLOCA_FREE(store_file_tmp);
        return -1;
    }
    logfile(LOG_DEBUG, _("[%s] = fd #%d"), store_file, client->write_fd);
    if (safe_write(client->write_fd,
                   client->read_buf + (size_t) 9U + client->key_len,
                   client->data_len) < 0) {
        logfile(LOG_WARNING, _("Write error: [%s]"), strerror(errno));
    }
    (void) close(client->write_fd);
    client->write_fd = -1;
    logfile(LOG_DEBUG,
            _("Renaming [%s] to [%s]"), store_file_tmp, store_file);
    if (rename(store_file_tmp, store_file) != 0) {
        logfile(LOG_WARNING, _("Unable to rename [%s] to [%s]: [%s]"),
                store_file_tmp, store_file, strerror(errno));
        (void) unlink(store_file_tmp);
        ALLOCA_FREE(store_file);
        ALLOCA_FREE(store_file_tmp);
        return -1;
    }
    ALLOCA_FREE(store_file);
    ALLOCA_FREE(store_file_tmp);
    if ((client->returncode_bufev =
         bufferevent_new(client->client_fd,
                         returncode_bufferev_read_cb,
                         returncode_bufferev_write_cb,
                         returncode_bufferev_error_cb,
                         client)) == NULL) {
        logfile(LOG_WARNING, _("Unable to create a bufferevent for fd #%d"),
                client->client_fd);
    }
    (void) bufferevent_write(client->returncode_bufev, (void *) RETURNCODE_OK,
                             sizeof RETURNCODE_OK - (size_t) 1U);

    return 0;
}
Exemplo n.º 15
0
static int altlog_writexfer_xferlog(const int upload,
                    const char * const filename,
                    const off_t size,
                    const double duration)
{
    char date[sizeof "Mon Apr 13 12:34:56 1975"];
    struct tm *tm;
    char *alloca_line;
    const char *host_ = *host != 0 ? host : "-";
    const char *account_ = *account != 0 ? account : "-";
    char *quoted_filename;
    size_t filename_idx;
    time_t now;
    size_t line_size;
    size_t filename_size;
    char c;

    if ((now = time(NULL)) == (time_t) -1 ||
        (tm = localtime(&now)) == NULL ||
        tm->tm_mon > 11 || tm->tm_mon < 0 ||
        tm->tm_wday > 6 || tm->tm_wday < 0) {
        return -1;
    }
    if (SNCHECK(snprintf(date, sizeof date,
                         "%s %s %02d %02d:%02d:%02d %d",
                         week_days[tm->tm_wday], months[tm->tm_mon],
                         tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
                         tm->tm_year + 1900), sizeof date)) {
        return -1;
    }
    if ((filename_idx = strlen(filename)) <= (size_t) 0U) {
        return -1;
    }
    filename_size = filename_idx + (size_t) 1U;
    if ((quoted_filename = ALLOCA(filename_size)) == NULL) {
        return -1;
    }

    quoted_filename[filename_idx] = 0;
    do {
        filename_idx--;
        c = filename[filename_idx];
        if (isspace((unsigned char) c) || ISCTRLCODE(c)) {
            c = '_';
        }
        quoted_filename[filename_idx] = c;
    } while (filename_idx > (size_t) 0U);

    line_size = (sizeof date - 1U) + (sizeof " " - 1U) +
        (size_t) 16U /* duration */ + (sizeof " " - 1U) +
        strlen(host_) + (sizeof " " - 1U) +
        (size_t) 20U /* size */ + (sizeof " " - 1U) +
        (filename_size - 1U) + (sizeof " " - 1U) +
        (size_t) 1U /* type */ + (sizeof " _ " - 1U) +
        (size_t) 1U /* direction */ + (sizeof " " - 1U) +
        (size_t) 1U /* anonymous */ + (sizeof " " - 1U) +
        strlen(account_) + (sizeof " ftp 1 * c\n" - 1U) + (size_t) 1U;
    if ((alloca_line = ALLOCA(line_size)) == NULL) {
        ALLOCA_FREE(quoted_filename);
        return -1;
    }
    if (!SNCHECK(snprintf(alloca_line, line_size,
                          "%s %lu %s %llu %s %c _ %c %c %s ftp 1 * c\n",
                          date, (unsigned long) (duration + 0.5),
                          host_, (unsigned long long) size,
                          quoted_filename,
                          type == 1 ? 'a' : 'b',
                          upload != 0 ? 'i' : 'o',
                          loggedin != 0 ? 'r' : 'a',
                          account_), line_size)) {
        altlog_write(alloca_line);
    }
    ALLOCA_FREE(quoted_filename);
    ALLOCA_FREE(alloca_line);

    return 0;
}
Exemplo n.º 16
0
static int altlog_writexfer_clf(const int upload,
                                const char * const filename,
                                const off_t size)
{
    char date[sizeof "13/Apr/1975:12:34:56 +0100"];
    struct tm *tm;
    char *alloca_line;
    const char *host_ = *host != 0 ? host : "-";
    const char *account_ = *account != 0 ? account : "-";
    char *quoted_filename;
    time_t now;
    long diff;
    int sign;
    size_t line_size;

    if ((now = time(NULL)) == (time_t) -1 ||
        (tm = localtime(&now)) == NULL ||
        tm->tm_mon > 11 || tm->tm_mon < 0) {
        return -1;
    }
# ifdef HAVE_STRUCT_TM_TM_GMTOFF
    diff = -(tm->tm_gmtoff) / 60L;
# elif defined(HAVE_SCALAR_TIMEZONE)
    diff = -(timezone) / 60L;
# else
    {
        struct tm gmt;
        struct tm *t;
        int days, hours, minutes;

        gmt = *gmtime(&now);
        t = localtime(&now);
        days = t->tm_yday - gmt.tm_yday;
        hours = ((days < -1 ? 24 : 1 < days ? -24 : days * 24)
                 + t->tm_hour - gmt.tm_hour);
        minutes = hours * 60 + t->tm_min - gmt.tm_min;
        diff = -minutes;
    }
# endif
    if (diff > 0L) {
        sign = '+';
    } else {
        sign = '-';
        diff = -diff;
    }

    if (SNCHECK(snprintf(date, sizeof date,
                         "%02d/%s/%d:%02d:%02d:%02d %c%02ld%02ld",
                         tm->tm_mday, months[tm->tm_mon], tm->tm_year + 1900,
                         tm->tm_hour, tm->tm_min, tm->tm_sec,
                         sign, diff / 60L, diff % 60L), sizeof date)) {
        return -1;
    }
    if ((quoted_filename = urlencode(filename)) == NULL) {
        return -1;
    }
    line_size = strlen(host_) + (sizeof " - " - 1U) + strlen(account_) +
        (sizeof " [" - 1U) + (sizeof date - 1U) + (sizeof "] \"" - 1U) +
        3U /* GET / PUT */ + (sizeof " " - 1U) + strlen(quoted_filename) +
        (sizeof "\" 200 18446744073709551616\n" - 1U) + 1U;
    if ((alloca_line = ALLOCA(line_size)) == NULL) {
        return -1;
    }
    if (!SNCHECK(snprintf(alloca_line, line_size,
                          "%s - %s [%s] \"%s %s\" 200 %llu\n",
                          host_, account_, date,
                          upload == 0 ? "GET" : "PUT", quoted_filename,
                          (unsigned long long) size), line_size)) {
        altlog_write(alloca_line);
    }
    if (quoted_filename != filename) {
        free(quoted_filename);
    }
    ALLOCA_FREE(alloca_line);

    return 0;
}
Exemplo n.º 17
0
static int client_process_fetch(Client * const client)
{
    char *store_file;
    char *store_file_pnt;
    size_t sizeof_store_file;
    struct stat st;

    logfile(LOG_DEBUG, _("client_process_fetch, fd #%d"), client->client_fd);
    if (client->offset_read_buf < (size_t) 6U) {
        return -1;
    }
    sizeof_store_file = (sizeof "/") - (size_t) 1U +
        client->key_len + (size_t) 1U;
    if ((store_file = ALLOCA(sizeof_store_file)) == NULL) {
        logfile(LOG_WARNING, _("Out of stack for ALLOCA"));
        return -1;
    }
    store_file_pnt = store_file;
    *store_file_pnt++ = '/';
    if (validate_key(client->read_buf + (size_t) 5U, client->key_len) != 0) {
        ALLOCA_FREE(store_file);
        logfile(LOG_WARNING, _("Invalid key name"));
        return -1;
    }
    memcpy(store_file_pnt, client->read_buf + (size_t) 5U, client->key_len);
    store_file_pnt += client->key_len;
    *store_file_pnt = 0;
    logfile(LOG_DEBUG, _("Reading [%s]"), store_file);
    if ((client->read_fd = open(store_file, O_RDONLY)) == -1) {
        logfile(LOG_DEBUG, _("Unable to fetch [%s]: [%s]"), store_file,
                strerror(errno));
        ALLOCA_FREE(store_file);
        return -1;
    }
    logfile(LOG_DEBUG, _("[%s] = fd #%d"), store_file, client->read_fd);
    if (fstat(client->read_fd, &st) != 0 || st.st_size <= (off_t) 0) {        
        logfile(LOG_DEBUG, _("Unable to stat a previous key (%s) : [%s]"),
                store_file, strerror(errno));
        (void) close(client->read_fd);
        client->read_fd = -1;
        ALLOCA_FREE(store_file);
        return -1;
    }
    if ((client->read_mapped_zone = mmap(NULL, st.st_size, PROT_READ,
                                         MAP_SHARED, client->read_fd,
                                         (off_t) 0)) == NULL) {
        logfile(LOG_WARNING, _("Unable to map in memory: [%s]"),
                strerror(errno));
        (void) close(client->read_fd);
        client->read_fd = -1;
        ALLOCA_FREE(store_file);
        return -1;
    }
    ALLOCA_FREE(store_file);
    client->read_mapped_zone_length = st.st_size;
    if ((client->returncode_bufev =
         bufferevent_new(client->client_fd,
                         returncode_bufferev_read_cb,
                         returncode_bufferev_write_cb,
                         returncode_bufferev_error_cb,
                         client)) == NULL) {
        logfile(LOG_WARNING, _("Unable to create a bufferevent for fd #%d"),
                client->client_fd);
    }
    (void) bufferevent_write(client->returncode_bufev,
                             client->read_mapped_zone,
                             client->read_mapped_zone_length);

    return 0;
}
Exemplo n.º 18
0
static int do_mkdb(const char *dbfile, const char * const file)
{
    FILE *fp;
    char *index_dbfile;
    size_t sizeof_index_dbfile;
    char *data_dbfile;
    size_t sizeof_data_dbfile;
    char *s;
    PureDBW dbw;
    int ret = PW_ERROR_UNEXPECTED_ERROR;
    char line[LINE_MAX];
    
    if (dbfile == NULL || *dbfile == 0) {
        char *dbfile_;
        
        if ((dbfile_ = getenv(ENV_DEFAULT_PW_DB)) != NULL && *dbfile_ != 0) {
            dbfile = dbfile_;
        } else {        
            dbfile = DEFAULT_PW_DB;
        }
    }
    if (file == NULL) {
        fprintf(stderr, "Missing passwd file\n");
        return PW_ERROR_MISSING_PASSWD_FILE;
    }    
    if ((fp = fopen(file, "r")) == NULL) {
        perror("Unable to open the passwd file");
        return PW_ERROR_MISSING_PASSWD_FILE;
    }
    sizeof_index_dbfile = strlen(dbfile) + sizeof NEWPASSWD_INDEX_SUFFIX;
    if ((index_dbfile = ALLOCA(sizeof_index_dbfile)) == NULL) {
        fclose(fp);
        no_mem();
    }
    sizeof_data_dbfile = strlen(dbfile) + sizeof NEWPASSWD_DATA_SUFFIX;
    if ((data_dbfile = ALLOCA(sizeof_data_dbfile)) == NULL) {
        fclose(fp);
        ALLOCA_FREE(index_dbfile);
        no_mem();
    }
    snprintf(index_dbfile, sizeof_index_dbfile, "%s%s",
             dbfile, NEWPASSWD_INDEX_SUFFIX);
    snprintf(data_dbfile, sizeof_data_dbfile, "%s%s",
             dbfile, NEWPASSWD_DATA_SUFFIX);
    if (puredbw_open(&dbw, index_dbfile, data_dbfile, dbfile) != 0) {
        perror("Unable to create the database");
        goto err;
    }
    while (fgets(line, (int) sizeof line - 1U, fp) != NULL) {
        strip_lf(line);
        if (*line == PW_LINE_COMMENT) {
            continue;
        }
        if (*line == 0 || (s = strchr(line, *PW_LINE_SEP)) == NULL ||
            s[1] == 0) {
            continue;
        }
        *s++ = 0;
        if (puredbw_add_s(&dbw, line, s) != 0) {
            perror("Error while indexing a new entry");
            goto err;
        }
    }
    if (puredbw_close(&dbw) != 0) {
        perror("Unable to close the database");
    } else {
        ret = 0;
    }
    err:
    puredbw_free(&dbw);
    ALLOCA_FREE(index_dbfile);
    ALLOCA_FREE(data_dbfile);    
    fclose(fp);
    
    return ret;
}