lib/csv.c

   1 /* CSV
   2  * Copyright (C) 2013 Cumulus Networks, Inc.
   3  *
   4  * This file is part of Quagga.
   5  *
   6  * Quagga is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * Quagga is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <stdarg.h>
  24 #include <assert.h>
  25 #include <sys/queue.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include "csv.h"
  29
  30 #define DEBUG_E 1
  31 #define DEBUG_V 1
  32
  33 #define log_error(fmt, ...)                                                    \
  34         do {                                                                   \
  35                 if (DEBUG_E)                                                   \
  36                         fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__,          \
  37                                 __LINE__, __func__, ##__VA_ARGS__);            \
  38         } while (0)
  39
  40 #define log_verbose(fmt, ...)                                                  \
  41         do {                                                                   \
  42                 if (DEBUG_V)                                                   \
  43                         fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__,          \
  44                                 __LINE__, __func__, __VA_ARGS__);              \
  45         } while (0)
  46
  47 struct _csv_field_t_ {
  48         TAILQ_ENTRY(_csv_field_t_) next_field;
  49         char *field;
  50         int field_len;
  51 };
  52
  53 struct _csv_record_t_ {
  54         TAILQ_HEAD(, _csv_field_t_) fields;
  55         TAILQ_ENTRY(_csv_record_t_) next_record;
  56         char *record;
  57         int rec_len;
  58 };
  59
  60 struct _csv_t_ {
  61         TAILQ_HEAD(, _csv_record_t_) records;
  62         char *buf;
  63         int buflen;
  64         int csv_len;
  65         int pointer;
  66         int num_recs;
  67 };
  68
  69
  70 int csvlen(csv_t *csv)
  71 {
  72         return (csv->csv_len);
  73 }
  74
  75 csv_t *csv_init(csv_t *csv, char *buf, int buflen)
  76 {
  77         if (csv == NULL) {
  78                 csv = malloc(sizeof(csv_t));
  79                 if (csv == NULL) {
  80                         log_error("CSV Malloc failed\n");
  81                         return (NULL);
  82                 }
  83         }
  84         memset(csv, 0, sizeof(csv_t));
  85
  86         csv->buf = buf;
  87         csv->buflen = buflen;
  88         TAILQ_INIT(&(csv->records));
  89         return (csv);
  90 }
  91
  92 void csv_clean(csv_t *csv)
  93 {
  94         csv_record_t *rec;
  95         csv_record_t *rec_n;
  96
  97         rec = TAILQ_FIRST(&(csv->records));
  98         while (rec != NULL) {
  99                 rec_n = TAILQ_NEXT(rec, next_record);
 100                 csv_remove_record(csv, rec);
 101                 rec = rec_n;
 102         }
 103 }
 104
 105 void csv_free(csv_t *csv)
 106 {
 107         if (csv != NULL) {
 108                 free(csv);
 109         }
 110 }
 111
 112 static void csv_init_record(csv_record_t *record)
 113 {
 114         TAILQ_INIT(&(record->fields));
 115         record->rec_len = 0;
 116 }
 117
 118 csv_record_t *csv_record_iter(csv_t *csv)
 119 {
 120         return (TAILQ_FIRST(&(csv->records)));
 121 }
 122
 123 csv_record_t *csv_record_iter_next(csv_record_t *rec)
 124 {
 125         if (!rec)
 126                 return NULL;
 127         return (TAILQ_NEXT(rec, next_record));
 128 }
 129
 130 char *csv_field_iter(csv_record_t *rec, csv_field_t **fld)
 131 {
 132         if (!rec)
 133                 return NULL;
 134         *fld = TAILQ_FIRST(&(rec->fields));
 135         return ((*fld)->field);
 136 }
 137
 138 char *csv_field_iter_next(csv_field_t **fld)
 139 {
 140         *fld = TAILQ_NEXT(*fld, next_field);
 141         if ((*fld) == NULL) {
 142                 return (NULL);
 143         }
 144         return ((*fld)->field);
 145 }
 146
 147 int csv_field_len(csv_field_t *fld)
 148 {
 149         if (fld) {
 150                 return fld->field_len;
 151         }
 152         return 0;
 153 }
 154
 155 static void csv_decode_record(csv_record_t *rec)
 156 {
 157         char *curr = rec->record;
 158         char *field;
 159         csv_field_t *fld;
 160
 161         field = strpbrk(curr, ",");
 162         while (field != NULL) {
 163                 fld = malloc(sizeof(csv_field_t));
 164                 if (fld) {
 165                         TAILQ_INSERT_TAIL(&(rec->fields), fld, next_field);
 166                         fld->field = curr;
 167                         fld->field_len = field - curr;
 168                 }
 169                 curr = field + 1;
 170                 field = strpbrk(curr, ",");
 171         }
 172         field = strstr(curr, "\n");
 173         if (!field)
 174                 return;
 175
 176         fld = malloc(sizeof(csv_field_t));
 177         if (fld) {
 178                 fld->field = curr;
 179                 fld->field_len = field - curr;
 180                 TAILQ_INSERT_TAIL(&(rec->fields), fld, next_field);
 181         }
 182 }
 183
 184 static csv_field_t *csv_add_field_to_record(csv_t *csv, csv_record_t *rec,
 185                                             char *col)
 186 {
 187         csv_field_t *fld;
 188         char *str = rec->record;
 189         int rlen = rec->rec_len;
 190         int blen = csv->buflen;
 191
 192         fld = malloc(sizeof(csv_field_t));
 193         if (!fld) {
 194                 log_error("field malloc failed\n");
 195                 /* more cleanup needed */
 196                 return (NULL);
 197         }
 198         TAILQ_INSERT_TAIL(&(rec->fields), fld, next_field);
 199         fld->field = str + rlen;
 200         fld->field_len = snprintf((str + rlen), (blen - rlen), "%s", col);
 201         rlen += fld->field_len;
 202         rec->rec_len = rlen;
 203         return fld;
 204 }
 205
 206 csv_record_t *csv_encode(csv_t *csv, int count, ...)
 207 {
 208         int tempc;
 209         va_list list;
 210         char *buf = csv->buf;
 211         int len = csv->buflen;
 212         int pointer = csv->pointer;
 213         char *str = NULL;
 214         char *col;
 215         csv_record_t *rec;
 216         csv_field_t *fld;
 217
 218         if (buf) {
 219                 str = buf + pointer;
 220         } else {
 221                 /* allocate sufficient buffer */
 222                 str = (char *)malloc(csv->buflen);
 223                 if (!str) {
 224                         log_error("field str malloc failed\n");
 225                         return (NULL);
 226                 }
 227         }
 228
 229         va_start(list, count);
 230         rec = malloc(sizeof(csv_record_t));
 231         if (!rec) {
 232                 log_error("record malloc failed\n");
 233                 if (!buf)
 234                         free(str);
 235                 va_end(list);
 236                 return (NULL);
 237         }
 238         csv_init_record(rec);
 239         rec->record = str;
 240         TAILQ_INSERT_TAIL(&(csv->records), rec, next_record);
 241         csv->num_recs++;
 242
 243         /**
 244          * Iterate through the fields passed as a variable list and add them
 245          */
 246         for (tempc = 0; tempc < count; tempc++) {
 247                 col = va_arg(list, char *);
 248                 fld = csv_add_field_to_record(csv, rec, col);
 249                 if (!fld) {
 250                         log_error("fld malloc failed\n");
 251                         csv_remove_record(csv, rec);
 252                         va_end(list);
 253                         return (NULL);
 254                 }
 255                 if (tempc < (count - 1)) {
 256                         rec->rec_len += snprintf((str + rec->rec_len),
 257                                                  (len - rec->rec_len), ",");
 258                 }
 259         }
 260         rec->rec_len +=
 261                 snprintf((str + rec->rec_len), (len - rec->rec_len), "\n");
 262         va_end(list);
 263         csv->csv_len += rec->rec_len;
 264         csv->pointer += rec->rec_len;
 265         return (rec);
 266 }
 267
 268 int csv_num_records(csv_t *csv)
 269 {
 270         if (csv) {
 271                 return csv->num_recs;
 272         }
 273         return 0;
 274 }
 275
 276 csv_record_t *csv_encode_record(csv_t *csv, csv_record_t *rec, int count, ...)
 277 {
 278         int tempc;
 279         va_list list;
 280         char *str;
 281         char *col;
 282         csv_field_t *fld = NULL;
 283         int i;
 284
 285         va_start(list, count);
 286         str = csv_field_iter(rec, &fld);
 287         for (tempc = 0; tempc < count; tempc++) {
 288                 col = va_arg(list, char *);
 289                 for (i = 0; i < fld->field_len; i++) {
 290                         str[i] = col[i];
 291                 }
 292                 str = csv_field_iter_next(&fld);
 293         }
 294         va_end(list);
 295         return (rec);
 296 }
 297
 298 csv_record_t *csv_append_record(csv_t *csv, csv_record_t *rec, int count, ...)
 299 {
 300         int tempc;
 301         va_list list;
 302         int len = csv->buflen, tlen;
 303         char *str;
 304         csv_field_t *fld;
 305         char *col;
 306
 307         if (csv->buf) {
 308                 /* not only works with discrete bufs */
 309                 return NULL;
 310         }
 311
 312         if (!rec) {
 313                 /* create a new rec */
 314                 rec = calloc(1, sizeof(csv_record_t));
 315                 if (!rec) {
 316                         log_error("record malloc failed\n");
 317                         return NULL;
 318                 }
 319                 csv_init_record(rec);
 320                 rec->record = calloc(1, csv->buflen);
 321                 if (!rec->record) {
 322                         log_error("field str malloc failed\n");
 323                         free(rec);
 324                         return NULL;
 325                 }
 326                 csv_insert_record(csv, rec);
 327         }
 328
 329         str = rec->record;
 330
 331         va_start(list, count);
 332
 333         if (rec->rec_len && (str[rec->rec_len - 1] == '\n'))
 334                 str[rec->rec_len - 1] = ',';
 335
 336         /**
 337          * Iterate through the fields passed as a variable list and add them
 338          */
 339         tlen = rec->rec_len;
 340         for (tempc = 0; tempc < count; tempc++) {
 341                 col = va_arg(list, char *);
 342                 fld = csv_add_field_to_record(csv, rec, col);
 343                 if (!fld) {
 344                         log_error("fld malloc failed\n");
 345                         break;
 346                 }
 347                 if (tempc < (count - 1)) {
 348                         rec->rec_len += snprintf((str + rec->rec_len),
 349                                                  (len - rec->rec_len), ",");
 350                 }
 351         }
 352         rec->rec_len +=
 353                 snprintf((str + rec->rec_len), (len - rec->rec_len), "\n");
 354         va_end(list);
 355         csv->csv_len += (rec->rec_len - tlen);
 356         csv->pointer += (rec->rec_len - tlen);
 357         return (rec);
 358 }
 359
 360 int csv_serialize(csv_t *csv, char *msgbuf, int msglen)
 361 {
 362         csv_record_t *rec;
 363         int offset = 0;
 364
 365         if (!csv || !msgbuf)
 366                 return -1;
 367
 368         rec = csv_record_iter(csv);
 369         while (rec != NULL) {
 370                 if ((offset + rec->rec_len) >= msglen)
 371                         return -1;
 372                 offset += sprintf(&msgbuf[offset], "%s", rec->record);
 373                 rec = csv_record_iter_next(rec);
 374         }
 375
 376         return 0;
 377 }
 378
 379 void csv_clone_record(csv_t *csv, csv_record_t *in_rec, csv_record_t **out_rec)
 380 {
 381         char *curr;
 382         csv_record_t *rec;
 383
 384         /* first check if rec belongs to this csv */
 385         if (!csv_is_record_valid(csv, in_rec)) {
 386                 log_error("rec not in this csv\n");
 387                 return;
 388         }
 389
 390         /* only works with csv with discrete bufs */
 391         if (csv->buf) {
 392                 log_error(
 393                         "un-supported for this csv type - single buf detected\n");
 394                 return;
 395         }
 396
 397         /* create a new rec */
 398         rec = calloc(1, sizeof(csv_record_t));
 399         if (!rec) {
 400                 log_error("record malloc failed\n");
 401                 return;
 402         }
 403         csv_init_record(rec);
 404         curr = calloc(1, csv->buflen);
 405         if (!curr) {
 406                 log_error("field str malloc failed\n");
 407                 free(rec);
 408                 return;
 409         }
 410         rec->record = curr;
 411         rec->rec_len = in_rec->rec_len;
 412         strcpy(rec->record, in_rec->record);
 413
 414         /* decode record into fields */
 415         csv_decode_record(rec);
 416
 417         *out_rec = rec;
 418 }
 419
 420 void csv_remove_record(csv_t *csv, csv_record_t *rec)
 421 {
 422         csv_field_t *fld, *p_fld;
 423
 424         /* first check if rec belongs to this csv */
 425         if (!csv_is_record_valid(csv, rec)) {
 426                 log_error("rec not in this csv\n");
 427                 return;
 428         }
 429
 430         /* remove fields */
 431         csv_field_iter(rec, &fld);
 432         while (fld) {
 433                 p_fld = fld;
 434                 csv_field_iter_next(&fld);
 435                 TAILQ_REMOVE(&(rec->fields), p_fld, next_field);
 436                 free(p_fld);
 437         }
 438
 439         TAILQ_REMOVE(&(csv->records), rec, next_record);
 440
 441         csv->num_recs--;
 442         csv->csv_len -= rec->rec_len;
 443         csv->pointer -= rec->rec_len;
 444         if (!csv->buf)
 445                 free(rec->record);
 446         free(rec);
 447 }
 448
 449 void csv_insert_record(csv_t *csv, csv_record_t *rec)
 450 {
 451         /* first check if rec already in csv */
 452         if (csv_is_record_valid(csv, rec)) {
 453                 log_error("rec already in this csv\n");
 454                 return;
 455         }
 456
 457         /* we can only insert records if no buf was supplied during csv init */
 458         if (csv->buf) {
 459                 log_error(
 460                         "un-supported for this csv type - single buf detected\n");
 461                 return;
 462         }
 463
 464         /* do we go beyond the max buf set for this csv ?*/
 465         if ((csv->csv_len + rec->rec_len) > csv->buflen) {
 466                 log_error("cannot insert - exceeded buf size\n");
 467                 return;
 468         }
 469
 470         TAILQ_INSERT_TAIL(&(csv->records), rec, next_record);
 471         csv->num_recs++;
 472         csv->csv_len += rec->rec_len;
 473         csv->pointer += rec->rec_len;
 474 }
 475
 476 csv_record_t *csv_concat_record(csv_t *csv, csv_record_t *rec1,
 477                                 csv_record_t *rec2)
 478 {
 479         char *curr;
 480         char *ret;
 481         csv_record_t *rec;
 482
 483         /* first check if rec1 and rec2 belong to this csv */
 484         if (!csv_is_record_valid(csv, rec1)
 485             || !csv_is_record_valid(csv, rec2)) {
 486                 log_error("rec1 and/or rec2 invalid\n");
 487                 return (NULL);
 488         }
 489
 490         /* we can only concat records if no buf was supplied during csv init */
 491         if (csv->buf) {
 492                 log_error(
 493                         "un-supported for this csv type - single buf detected\n");
 494                 return (NULL);
 495         }
 496
 497         /* create a new rec */
 498         rec = calloc(1, sizeof(csv_record_t));
 499         if (!rec) {
 500                 log_error("record malloc failed\n");
 501                 return (NULL);
 502         }
 503         csv_init_record(rec);
 504
 505         curr = (char *)calloc(1, csv->buflen);
 506         if (!curr) {
 507                 log_error("field str malloc failed\n");
 508                 goto out_rec;
 509         }
 510         rec->record = curr;
 511
 512         /* concat the record string */
 513         ret = strstr(rec1->record, "\n");
 514         if (!ret) {
 515                 log_error("rec1 str not properly formatted\n");
 516                 goto out_curr;
 517         }
 518
 519         snprintf(curr, (int)(ret - rec1->record + 1), "%s", rec1->record);
 520         strcat(curr, ",");
 521
 522         ret = strstr(rec2->record, "\n");
 523         if (!ret) {
 524                 log_error("rec2 str not properly formatted\n");
 525                 goto out_curr;
 526         }
 527
 528         snprintf((curr + strlen(curr)), (int)(ret - rec2->record + 1), "%s",
 529                  rec2->record);
 530         strcat(curr, "\n");
 531         rec->rec_len = strlen(curr);
 532
 533         /* paranoia */
 534         assert(csv->buflen
 535                > (csv->csv_len - rec1->rec_len - rec2->rec_len + rec->rec_len));
 536
 537         /* decode record into fields */
 538         csv_decode_record(rec);
 539
 540         /* now remove rec1 and rec2 and insert rec into this csv */
 541         csv_remove_record(csv, rec1);
 542         csv_remove_record(csv, rec2);
 543         csv_insert_record(csv, rec);
 544
 545         return rec;
 546
 547 out_curr:
 548         free(curr);
 549 out_rec:
 550         free(rec);
 551         return NULL;
 552 }
 553
 554 void csv_decode(csv_t *csv, char *inbuf)
 555 {
 556         char *buf;
 557         char *pos;
 558         csv_record_t *rec;
 559
 560         buf = (inbuf) ? inbuf : csv->buf;
 561         pos = strpbrk(buf, "\n");
 562         while (pos != NULL) {
 563                 rec = calloc(1, sizeof(csv_record_t));
 564                 if (!rec)
 565                         return;
 566                 csv_init_record(rec);
 567                 TAILQ_INSERT_TAIL(&(csv->records), rec, next_record);
 568                 csv->num_recs++;
 569                 if (csv->buf)
 570                         rec->record = buf;
 571                 else {
 572                         rec->record = calloc(1, csv->buflen);
 573                         if (!rec->record) {
 574                                 log_error("field str malloc failed\n");
 575                                 return;
 576                         }
 577                         strncpy(rec->record, buf, pos - buf + 1);
 578                 }
 579                 rec->rec_len = pos - buf + 1;
 580                 /* decode record into fields */
 581                 csv_decode_record(rec);
 582                 buf = pos + 1;
 583                 pos = strpbrk(buf, "\n");
 584         }
 585 }
 586
 587 int csv_is_record_valid(csv_t *csv, csv_record_t *in_rec)
 588 {
 589         csv_record_t *rec;
 590         int valid = 0;
 591
 592         rec = csv_record_iter(csv);
 593         while (rec) {
 594                 if (rec == in_rec) {
 595                         valid = 1;
 596                         break;
 597                 }
 598                 rec = csv_record_iter_next(rec);
 599         }
 600
 601         return valid;
 602 }
 603
 604 void csv_dump(csv_t *csv)
 605 {
 606         csv_record_t *rec;
 607         csv_field_t *fld;
 608         char *str;
 609
 610         rec = csv_record_iter(csv);
 611         while (rec != NULL) {
 612                 str = csv_field_iter(rec, &fld);
 613                 while (str != NULL) {
 614                         fprintf(stderr, "%s\n", str);
 615                         str = csv_field_iter_next(&fld);
 616                 }
 617                 rec = csv_record_iter_next(rec);
 618         }
 619 }
 620
 621 #ifdef TEST_CSV
 622
 623 static int get_memory_usage(pid_t pid)
 624 {
 625         int fd, data, stack;
 626         char buf[4096], status_child[BUFSIZ];
 627         char *vm;
 628
 629         sprintf(status_child, "/proc/%d/status", pid);
 630         if ((fd = open(status_child, O_RDONLY)) < 0)
 631                 return -1;
 632
 633         read(fd, buf, 4095);
 634         buf[4095] = '\0';
 635         close(fd);
 636
 637         data = stack = 0;
 638
 639         vm = strstr(buf, "VmData:");
 640         if (vm) {
 641                 sscanf(vm, "%*s %d", &data);
 642         }
 643         vm = strstr(buf, "VmStk:");
 644         if (vm) {
 645                 sscanf(vm, "%*s %d", &stack);
 646         }
 647
 648         return data + stack;
 649 }
 650
 651 int main()
 652 {
 653         char buf[10000];
 654         csv_t csv;
 655         int p;
 656         int i, j;
 657         csv_record_t *rec;
 658         csv_field_t *fld;
 659         char *str;
 660         char hdr1[32], hdr2[32];
 661
 662         log_verbose("Mem: %ld\n", get_memory_usage(getpid()));
 663         csv_init(&csv, buf, 256);
 664         sprintf(hdr1, "%4u", 0);
 665         sprintf(hdr2, "%4u", 1);
 666         log_verbose("(%d/%d/%d/%d)\n", strlen(hdr1), strlen(hdr2), atoi(hdr1),
 667                     atoi(hdr2));
 668         rec = csv_encode(&csv, 2, hdr1, hdr2);
 669         csv_encode(&csv, 4, "name", "age", "sex", "hei");
 670         csv_encode(&csv, 3, NULL, "0", NULL);
 671         csv_encode(&csv, 2, "p", "35");
 672         for (i = 0; i < 50; i++) {
 673                 csv_encode(&csv, 2, "p", "10");
 674         }
 675         csv_encode(&csv, 2, "pdfadfadfadsadsaddfdfdsfdsd", "35444554545454545");
 676         log_verbose("%s\n", buf);
 677         sprintf(hdr1, "%4u", csv.csv_len);
 678         sprintf(hdr2, "%4u", 1);
 679         log_verbose("(%d/%d/%d/%d)\n", strlen(hdr1), strlen(hdr2), atoi(hdr1),
 680                     atoi(hdr2));
 681         rec = csv_encode_record(&csv, rec, 2, hdr1, hdr2);
 682         log_verbose("(%d/%d)\n%s\n", rec->rec_len, csv.csv_len, buf);
 683
 684         log_verbose("Mem: %ld\n", get_memory_usage(getpid()));
 685         csv_clean(&csv);
 686         log_verbose("Mem: %ld\n", get_memory_usage(getpid()));
 687         csv_init(&csv, buf, 256);
 688         csv_decode(&csv, NULL);
 689         log_verbose("AFTER DECODE\n");
 690         csv_dump(&csv);
 691         csv_clean(&csv);
 692         log_verbose("Mem: %ld\n", get_memory_usage(getpid()));
 693 }
 694 #endif