Beispiel #1
0
void log_write(struct bbs_msgbuf *msg)
{
    int index = -1;

    // print BBSLOG_POST logs as BBSLOG_USER
    index = msg->mtype == BBSLOG_POST ? BBSLOG_USER : msg->mtype;

    // log range
    if (index < 1 || index > LOG_RECORDS_SIZE)
        return;

    struct record_t *record = log_records + (index - 1);

    char ch = msg->mtext[0];
    msg->mtext[0] = 0;

    // print header
    char header[256];
    if (msg->mtype == BBSLOG_POST) {
        print_post_header(msg, header, 256);
    } else {
        struct tm *n;
        n = localtime(&msg->msgtime);

        snprintf(header, 256,
                 "[%02u/%02u %02u:%02u:%02u %5lu %lu] %s %c%s",
                 /* mon/day */ n->tm_mon + 1, n->tm_mday,
                 /* h:m:s */   n->tm_hour, n->tm_min, n->tm_sec,
                 (long int) msg->pid,
                 msg->mtype,
                 msg->userid,
                 ch,
                 &msg->mtext[1]);
    }
    int header_len = strlen(header);

    // write to buffer
    if (RECORD_FULL == record_append(record, header, header_len)) {
        // or flush and then write to disk
        record_flush(record);
        record_write(record, header, header_len);
    }
}
Beispiel #2
0
RECORD *dbf_read_next(DBF *dbf)
{
  RECORD *record = NULL;
  CELL *cell = NULL;
  DBF_FIELD *field;
  ssize_t count;
  char *buf, *cur, *tmp;
  int i;
  uint32 len = dbf->record_length;

  DBUG_ENTER("dbf_read_next");

  buf = cur = memset(dbf->record_buffer, 0, dbf->record_length+1);

  if((count=read(dbf->fd, buf, dbf->record_length+1)) < dbf->record_length+1)
  {
    if(count == 1 && buf[0] == DBF_EOF)
    {
      goto endoffile;
    }
    fprintf(stderr, "DBF: Error reading record: read only %i bytes, expected %i bytes\n", count, dbf->record_length+1);
    close(dbf->fd);
    DBUG_RETURN(NULL);
  }

  if(!(record = record_init(dbf)))
    DBUG_RETURN(NULL);

  /* status = cur[0] */
  cur++;

  for(field=dbf->fields, i=0; i<dbf->numfields; field++, i++)
  {
    cell = cell_init(field, &field->metadata);
    switch(field->type)
    {
    case DBF_CHARACTER:
      if(!(cell->data.character = (char *)strndup(cur, field->size)))
        goto oom;
      mygis_trim(cell->data.character, field->size);
      break;

    case DBF_DATE:
      if(!(cell->data.date = (char *)strndup(cur, field->size)))
        goto oom;
      break;

    case DBF_NUMBER:
      /* if field->decimals > 0, fall through to FLOATING */
      if(field->decimals == 0)
      {
        if(!(tmp = (char *)strndup(cur, field->size)))
          goto oom;
        cell->data.number = atoll(tmp);
        free(tmp);
        break;
      }

    case DBF_FLOATING:
      if(!(tmp = (char *)strndup(cur, field->size)))
        goto oom;
      cell->data.floating = atof(tmp);
      free(tmp);
      break;

    case DBF_LOGICAL:
      cell->data.logical = cur[0];
      break;

    case DBF_GENERAL:
    case DBF_MEMO:
    case DBF_PICTURE:
      fprintf(stderr, "Unsupported field type %c!  Please ask for support from the author!\n", field->type);
      return NULL;
    default:
      fprintf(stderr, "Unknown field type %c!\n", field->type);
      return NULL;
    }
    record_append(record, cell);
    cur += field->size;
  }

 endoffile:
  dbf->position++;
  DBUG_RETURN(record);

 oom:
  fprintf(stderr, "DBF: Out of memory!\n");
  DBUG_RETURN(NULL);
}