libical

ical.c (5278B)

---

 /*
  * Copy me if you can.
  * by 20h
  */
 
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <strings.h>
 #include <string.h>
 
 #include "ind.h"
 #include "ical.h"
 
 vitemprop_t *
 vitemprop_new(void)
 {
 	vitemprop_t *ret;
 
 	ret = mallocz(sizeof(vitemprop_t), 2);
 
 	return ret;
 }
 
 void
 vitemprop_free(vitemprop_t *prop)
 {
 	if (prop->name != NULL)
 		free(prop->name);
 	if (prop->params != NULL)
 		free(prop->params);
 	if (prop->value != NULL)
 		free(prop->value);
 
 	free(prop);
 }
 
 void
 vitemprop_print(vitemprop_t *prop)
 {
 	char *line, *lp, *cp;
 	int llen;
 
 	line = smprintf("%s%s%s:%s", prop->name,
 			(prop->params)? ";" : "",
 			(prop->params)? prop->params : "",
 			prop->value);
 	llen = strlen(line);
 	if (llen <= 73) {
 		printf("%s\r\n", line);
 		free(line);
 		return;
 	}
 
 	cp = memdupz(line, 73);
 	printf("%s\r\n", cp);
 	free(cp);
 	lp = line + 73;
 	llen -= 73;
 
 	for (; llen > 0;) {
 		cp = memdupz(lp, 72);
 		printf(" %s\r\n", cp);
 		free(cp);
 		lp += 72;
 		llen -= 72;
 	}
 	free(line);
 }
 
 vitem_t *
 vitem_new(void)
 {
 	vitem_t *ret;
 
 	ret = mallocz(sizeof(vitem_t), 2);
 
 	return ret;
 }
 
 void
 vitem_free(vitem_t *item)
 {
 	vitemprop_t *cur, *next;
 
 	for (cur = item->props; cur; cur = next) {
 		next = cur->next;
 
 		vitemprop_free(cur);
 	}
 
 	if (item->type != NULL)
 		free(item->type);
 
 	free(item);
 }
 
 void
 vitem_addprop(vitem_t *item, vitemprop_t *prop)
 {
 	if (item->props == NULL) {
 		item->props = prop;
 		item->lastp = prop;
 	} else {
 		item->lastp->next = prop;
 		prop->prev = item->lastp;
 		item->lastp = prop;
 	}
 	item->nprops++;
 }
 
 void
 vitem_print(vitem_t *item)
 {
 	vitemprop_t *elem;
 
 	printf("BEGIN:%s\n", item->type);
 	forlist(item->props, elem)
 		vitemprop_print(elem);
 	printf("END:%s\n", item->type);
 }
 
 vitems_t *
 vitems_new(void)
 {
 	vitems_t *ret;
 
 	ret = mallocz(sizeof(vitems_t), 2);
 
 	return ret;
 }
 
 void
 vitems_free(vitems_t *items)
 {
 	vitem_t *cur, *next;
 	vitemprop_t *pcur, *pnext;
 
 	for (cur = items->first; cur; cur = next) {
 		next = cur->next;
 		vitem_free(cur);
 	}
 
 	for (pcur = items->headers; pcur; pcur = pnext) {
 		pnext = pcur->next;
 		vitemprop_free(pcur);
 	}
 
 	free(items);
 }
 
 void
 vitems_addhdr(vitems_t *items, vitemprop_t *hdr)
 {
 	if (items->headers == NULL) {
 		items->headers = hdr;
 		items->lasth = hdr;
 	} else {
 		items->lasth->next = hdr;
 		hdr->prev = items->lasth;
 		items->lasth = hdr;
 	}
 	items->nheaders++;
 }
 
 void
 vitems_additem(vitems_t *items, vitem_t *item)
 {
 	if (items->first == NULL) {
 		items->first = item;
 		items->last = item;
 	} else {
 		items->last->next = item;
 		item->prev = items->last;
 		items->last = item;
 	}
 	items->nitems++;
 }
 
 void
 vitems_print(vitems_t *items)
 {
 	vitemprop_t *pelem;
 	vitem_t *ielem;
 
 	printf("BEGIN:VCALENDAR\r\n");
 	forlist(items->headers, pelem)
 		vitemprop_print(pelem);
 
 	forlist(items->first, ielem)
 		vitem_print(ielem);
 	printf("END:VCALENDAR\r\n");
 }
 
 enum {
 	STATE_INIT = 0x00,
 	STATE_VCALBEGIN,
 	STATE_VITEMBEGIN,
 	STATE_VCALEND
 };
 
 vitems_t *
 vitems_read(int fd)
 {
 	vitems_t *items;
 	vitem_t *item;
 	vitemprop_t *itemprop;
 	char *filebuf, *rp, *p, *sepp, *paramsp, buf[1024], *pbuf, *line,
 	     *oline;
 	int len, state, blen, lnum;
 
 	filebuf = readtoeoffd(fd, &len);
 	if (filebuf == NULL)
 		return NULL;
 
 	state = STATE_INIT;
 	items = vitems_new();
 	item = NULL;
 
 	rp = filebuf;
 	p = filebuf;
 	line = NULL;
 	lnum = 0;
 	for (;;) {
 		if (line != NULL)
 			free(line);
 		line = NULL;
 		if (oline != NULL)
 			line = oline;
 
 		if (rp == NULL || state == STATE_VCALEND)
 			break;
 
 		for (; (rp = sgets(buf, sizeof(buf)-1, &p));) {
 			lnum++;
 
 			blen = strlen(buf);
 			if (buf[blen-1] == '\r') {
 				buf[blen-1] = '\0';
 				blen--;
 			}
 
 			pbuf = NULL;
 			switch (buf[0]) {
 			case '\t':
 			case ' ':
 				line = memdupcat(line, strlen(line),
 						&buf[1], blen-1);
 				pbuf = line;
 				break;
 			default:
 				break;
 			}
 
 			if (pbuf == NULL) {
 				if (line != NULL) {
 					oline = memdupz(buf, blen);
 					break;
 				} else {
 					line = memdupz(buf, blen);
 				}
 			}
 
 		}
 		if (line == NULL)
 			break;
 
 		if (strlen(line) == 0)
 			continue;
 
 		sepp = strchr(line, ':');
 		if (sepp == NULL)
 			die("No ':' separator. (line: %d)\n", lnum);
 
 		sepp[0] = '\0';
 		sepp++;
 
 		if (!strcasecmp(line, "BEGIN")) {
 			if (!strcasecmp(sepp, "VCALENDAR")) {
 				state = STATE_VCALBEGIN;
 				continue;
 			} else {
 				state = STATE_VITEMBEGIN;
 
 				item = vitem_new();
 				item->type = memdupz(sepp,
 						strlen(sepp));
 				continue;
 			}
 		} else if (!strcasecmp(line, "END")) {
 			if (!strcasecmp(sepp, "VCALENDAR")) {
 				state = STATE_VCALEND;
 			} else {
 				if (item == NULL)
 					die("item == NULL (line: %d)\n", lnum);
 				vitems_additem(items, item);
 				item = NULL;
 			}
 			continue;
 		}
 
 		paramsp = strchr(line, ';');
 		if (paramsp != NULL) {
 			paramsp[0] = '\0';
 			paramsp++;
 		}
 
 		itemprop = vitemprop_new();
 		itemprop->name = memdupz(line, strlen(line));
 		if (paramsp != NULL) {
 			itemprop->params = memdupz(paramsp,
 					strlen(paramsp));
 		}
 		itemprop->value = memdupz(sepp,
 				strlen(sepp));
 
 		if (state == STATE_VCALBEGIN) {
 			vitems_addhdr(items, itemprop);
 		} else if (state == STATE_VITEMBEGIN) {
 			vitem_addprop(item, itemprop);
 		}
 	}
 
 	free(filebuf);
 
 	if (items->nitems < 1) {
 		vitems_free(items);
 		return NULL;
 	}
 
 	return items;
 }