summaryrefslogtreecommitdiffstats
path: root/pcp/pcpnet.c
diff options
context:
space:
mode:
Diffstat (limited to 'pcp/pcpnet.c')
-rw-r--r--pcp/pcpnet.c2223
1 files changed, 2223 insertions, 0 deletions
diff --git a/pcp/pcpnet.c b/pcp/pcpnet.c
new file mode 100644
index 0000000..fd1d70f
--- /dev/null
+++ b/pcp/pcpnet.c
@@ -0,0 +1,2223 @@
+/*
+** Copyright 2001-2002 Double Precision, Inc. See COPYING for
+** distribution information.
+*/
+
+
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/un.h>
+#include <rfc822/rfc822hdr.h>
+#include "pcp.h"
+#include "calendardir.h"
+
+#if HAVE_DIRENT_H
+#include <dirent.h>
+#else
+#define dirent direct
+#if HAVE_SYS_NDIR_H
+#include <sys/ndir.h>
+#endif
+#if HAVE_SYS_DIR_H
+#include <sys/dir.h>
+#endif
+#if HAVE_NDIR_H
+#include <ndir.h>
+#endif
+#endif
+
+#define HOSTNAMELEN 256
+
+#define EVENTID_MAXLEN 512
+#define ADDR_MAXLEN 512
+
+#define EVENTID_SSCANF "%511s"
+#define ADDR_SSCANF "%511s"
+
+struct PCPnet {
+ struct PCP pcp;
+ char *username;
+ char *authtoken;
+ char *sockname;
+ int fd;
+
+ char *readbuf;
+ size_t readbuflen;
+
+ char *readptr;
+ size_t readleft;
+
+ int haserrmsg;
+} ;
+
+struct PCPnet_new_eventid {
+ struct PCP_new_eventid eventid;
+ int isbooked;
+} ;
+
+static void pcp_close_quit_net(struct PCPnet *);
+static void pcp_close_net(struct PCPnet *);
+static int cleanup(struct PCPnet *);
+
+static struct PCP_new_eventid *neweventid(struct PCPnet *,
+ const char *,
+ struct PCP_save_event *);
+static void destroyeventid(struct PCPnet *, struct PCPnet_new_eventid *);
+
+static int commitevent(struct PCPnet *, struct PCPnet_new_eventid *,
+ struct PCP_commit *);
+static int bookevent(struct PCPnet *, struct PCPnet_new_eventid *,
+ struct PCP_commit *);
+
+static int listallevents(struct PCPnet *, struct PCP_list_all *);
+
+static int cancelevent(struct PCPnet *, const char *, int *);
+static int uncancelevent(struct PCPnet *, const char *,
+ int, struct PCP_uncancel *);
+static int deleteevent(struct PCPnet *, struct PCP_delete *);
+static int retrevent(struct PCPnet *, struct PCP_retr *);
+static int setacl(struct PCPnet *, const char *, int);
+static int listacl(struct PCPnet *,
+ int (*)(const char *, int, void *),
+ void *);
+static void noop(struct PCPnet *);
+
+static const char *getauthtoken(struct PCPnet *pcp)
+{
+ return (pcp->authtoken);
+}
+
+static const char *errmsg(struct PCPnet *pcp)
+{
+ if (pcp->haserrmsg)
+ return (pcp->readbuf);
+ return (strerror(errno));
+}
+
+static struct PCPnet *mkpcp(const char *username)
+{
+ struct PCPnet *pd=(struct PCPnet *)malloc(sizeof(struct PCPnet));
+ const char *p;
+
+ if (!pd)
+ return (NULL);
+
+ if (!*username)
+ {
+ free(pd);
+ errno=EIO;
+ return (NULL);
+ }
+
+ for (p=username; *p; p++)
+ if (isspace((int)(unsigned char)*p))
+ {
+ free(pd);
+ errno=EIO;
+ return (NULL);
+ }
+
+ memset(pd, 0, sizeof(*pd));
+
+ pd->fd= -1;
+ pd->username=strdup(username);
+ if (!pd->username)
+ {
+ free(pd);
+ return (NULL);
+ }
+
+ pd->pcp.authtoken_func=(const char *(*)(struct PCP *))getauthtoken;
+ pd->pcp.close_func= (void (*)(struct PCP *)) pcp_close_quit_net;
+ pd->pcp.cleanup_func= (int (*)(struct PCP *)) cleanup;
+
+ pd->pcp.create_new_eventid_func=
+ (struct PCP_new_eventid *(*)(struct PCP *, const char *,
+ struct PCP_save_event *))
+ neweventid;
+
+ pd->pcp.destroy_new_eventid_func=
+ (void (*)(struct PCP *, struct PCP_new_eventid *))
+ destroyeventid;
+
+ pd->pcp.commit_func=
+ (int (*)(struct PCP *, struct PCP_new_eventid *,
+ struct PCP_commit *))
+ commitevent;
+
+ pd->pcp.book_func=
+ (int (*)(struct PCP *, struct PCP_new_eventid *,
+ struct PCP_commit *))
+ bookevent;
+
+ pd->pcp.list_all_func=
+ (int (*)(struct PCP *, struct PCP_list_all *))
+ listallevents;
+
+ pd->pcp.cancel_func=
+ (int (*)(struct PCP *, const char *, int *))
+ cancelevent;
+
+ pd->pcp.uncancel_func=
+ (int (*)(struct PCP *, const char *, int,
+ struct PCP_uncancel *))
+ uncancelevent;
+
+ pd->pcp.delete_func=
+ (int (*)(struct PCP *, struct PCP_delete *))
+ deleteevent;
+
+ pd->pcp.retr_func=
+ (int (*)(struct PCP *, struct PCP_retr *))
+ retrevent;
+
+ pd->pcp.errmsg_func=
+ (const char *(*)(struct PCP *))
+ errmsg;
+
+ pd->pcp.noop_func=(void (*)(struct PCP *))noop;
+
+ pd->pcp.acl_func=
+ (int (*)(struct PCP *, const char *, int))setacl;
+ pd->pcp.listacl_func=
+ (int (*)(struct PCP *, int (*)(const char *, int, void *),
+ void *))listacl;
+
+ return (pd);
+}
+
+struct sock_list {
+ struct sock_list *next;
+ char *filename;
+} ;
+
+static int cmp_str(const void *a, const void *b)
+{
+ return (strcmp(*(const char **)a, *(const char **)b));
+}
+
+static int dowrite(struct PCPnet *pcp, const char *s, int l)
+{
+ if (l <= 0)
+ l=strlen(s);
+
+ if (pcp->fd < 0)
+ {
+ errno=ENETDOWN;
+ return (-1);
+ }
+
+ while (l)
+ {
+ int n=write(pcp->fd, s, l);
+
+ if (n <= 0)
+ {
+ errno=ENETDOWN;
+ close(pcp->fd);
+ pcp->fd= -1;
+ return (-1);
+ }
+
+ s += n;
+ l -= n;
+ }
+ return (0);
+}
+
+static int readch(struct PCPnet *pcp, size_t n)
+{
+ if (pcp->readleft == 0)
+ {
+ int l;
+ struct timeval tv;
+ fd_set fds;
+
+ /* Read the next chunk after the current line :-) */
+
+ if (n + BUFSIZ > pcp->readbuflen)
+ {
+ size_t nn=n+BUFSIZ;
+ char *p= pcp->readbuf ?
+ realloc(pcp->readbuf, nn):malloc(nn);
+ if (!p)
+ {
+ close(pcp->fd);
+ pcp->fd= -1;
+ return (-1);
+ }
+ pcp->readbuf=p;
+ pcp->readbuflen=nn;
+ }
+
+ pcp->readptr=pcp->readbuf + n;
+
+ FD_ZERO(&fds);
+ FD_SET(pcp->fd, &fds);
+ tv.tv_sec=300;
+ tv.tv_usec=0;
+ if (select(pcp->fd+1, &fds, NULL, NULL, &tv) <= 0)
+ {
+ errno=ETIMEDOUT;
+ close(pcp->fd);
+ pcp->fd= -1;
+ return (EOF);
+ }
+ l=read(pcp->fd, pcp->readptr, BUFSIZ);
+ if (l <= 0)
+ {
+ if (l == 0)
+ errno=0;
+ close(pcp->fd);
+ pcp->fd= -1;
+ errno=ECONNRESET;
+ return (EOF);
+ }
+ pcp->readleft=l;
+ }
+
+ --pcp->readleft;
+ return ((int)(unsigned char)*pcp->readptr++);
+}
+
+static int getfullreply(struct PCPnet *pcp)
+{
+ size_t n=0;
+ int ch;
+
+ for (;;)
+ {
+ size_t nn=n;
+
+ while ((ch=readch(pcp, nn)) != EOF)
+ {
+ if (ch == '\n')
+ break;
+ pcp->readbuf[nn++]=ch;
+ }
+
+ if (ch == EOF)
+ return (-1);
+
+ if (nn-n >= 4 &&
+ isdigit((int)(unsigned char)pcp->readbuf[n]) &&
+ isdigit((int)(unsigned char)pcp->readbuf[n+1]) &&
+ isdigit((int)(unsigned char)pcp->readbuf[n+2]) &&
+ isspace((int)(unsigned char)pcp->readbuf[n+3]))
+ {
+ pcp->readbuf[nn]=0;
+ break;
+ }
+ n= ++nn;
+ }
+
+ return (0);
+}
+
+static int getonelinereply(struct PCPnet *pcp)
+{
+ size_t nn;
+ int islast;
+
+ nn=0;
+ for (;;)
+ {
+ int ch;
+
+ while ((ch=readch(pcp, nn)) != EOF)
+ {
+ if (ch == '\n')
+ break;
+ pcp->readbuf[nn++]=ch;
+ if (nn >= 8192)
+ nn=8192;
+ }
+ pcp->readbuf[nn]=0;
+ if (ch == EOF)
+ return (-1);
+
+ if (!isdigit((int)(unsigned char)pcp->readbuf[0])
+ || !isdigit((int)(unsigned char)pcp->readbuf[1])
+ || !isdigit((int)(unsigned char)pcp->readbuf[2]))
+ {
+ nn=0;
+ continue;
+ }
+ islast= pcp->readbuf[3] != '-';
+ break;
+ }
+ return (islast);
+}
+
+
+static int docmd(struct PCPnet *pcp, const char *cmd, int cmdl)
+{
+ if (dowrite(pcp, cmd, cmdl) < 0)
+ return (-1);
+ return (getfullreply(pcp));
+}
+
+static int checkstatus(struct PCPnet *pcp, int *errcode)
+{
+ const char *p=strrchr(pcp->readbuf, '\n');
+ int n;
+
+ if (p)
+ ++p;
+ else
+ p=pcp->readbuf;
+ n=atoi(p);
+ if (errcode)
+ switch (n) {
+ case 504:
+ *errcode=PCP_ERR_EVENTNOTFOUND;
+ break;
+ case 506:
+ *errcode=PCP_ERR_EVENTLOCKED;
+ break;
+ }
+ return (n);
+}
+
+static char *getword(struct PCPnet *pcp, char **p)
+{
+ char *q;
+
+ while (**p && isspace((int)(unsigned char)**p))
+ ++*p;
+
+ if (!**p)
+ return (NULL);
+ q= *p;
+
+ while (**p && !isspace((int)(unsigned char)**p))
+ ++*p;
+
+ if (**p)
+ {
+ **p=0;
+ ++*p;
+ }
+ return (q);
+}
+
+/* Parse 102 response */
+
+static int parseauthtoken(struct PCPnet *pcp)
+{
+ char *p=pcp->readbuf;
+ char *q;
+
+ getword(pcp, &p); /* skip 102 */
+
+ q=getword(pcp, &p);
+
+ if (!q)
+ {
+ errno=EIO;
+ return (-1);
+ }
+
+ if (pcp->authtoken)
+ free(pcp->authtoken);
+
+ if ((p=strrchr(pcp->sockname, '/')) != 0)
+ ++p;
+ else
+ p=pcp->sockname;
+
+ if ((pcp->authtoken=malloc(strlen(p)+strlen(q)+2)) == NULL)
+ return (-1);
+ strcat(strcat(strcpy(pcp->authtoken, p), "/"), q);
+ return (0);
+}
+
+/* Parse 100 response */
+
+static int has100(struct PCPnet *pcp, const char *kw)
+{
+ char *p=pcp->readbuf;
+ int l = strlen(kw);
+
+ while (*p)
+ {
+ while (isdigit((int)(unsigned char)*p))
+ ++p;
+ if (*p != '\n')
+ ++p;
+
+ if (strncasecmp(p, kw, l) == 0 &&
+ (p[l] == 0 || isspace((int)(unsigned char)p[l])))
+ return (1);
+
+ while (*p)
+ if (*p++ == '\n')
+ break;
+ }
+ return (0);
+}
+
+static int doconnect(struct PCPnet *pcp, const char *dir, const char *username,
+ const char *sockname,
+ const char *clustername,
+ char **errmsg)
+{
+ DIR *dirp=opendir(dir);
+ struct sock_list *l=NULL;
+ struct dirent *de;
+ struct sock_list *nl;
+ unsigned i,cnt=0;
+ char **a;
+ int fd;
+ char *buf;
+ int clustername_l=clustername ? strlen(clustername):0;
+
+ if (errmsg)
+ *errmsg=0;
+
+ while (dirp && (de=readdir(dirp)) != NULL)
+ {
+ if (strchr(de->d_name, '.'))
+ continue;
+
+ if (sockname && strcmp(de->d_name, sockname))
+ continue;
+
+ /*
+ ** When the proxy connection comes in via the proxy cluster,
+ ** ignore the proxy cluster client's socket, so we don't end
+ ** up in an infinite loop!
+ */
+
+ if (clustername)
+ {
+ const char *p=de->d_name;
+
+ while (p && isdigit((int)(unsigned char)*p))
+ ++p;
+
+ if (strncasecmp(p, clustername, clustername_l) == 0
+ && p[clustername_l] == '.')
+ continue;
+ }
+
+ nl=malloc(sizeof(struct sock_list));
+
+ if (!nl || (nl->filename=malloc(strlen(dir)+2+
+ strlen(de->d_name))) == NULL)
+ {
+ if (nl) free(nl);
+
+ while ((nl=l) != NULL)
+ {
+ l=nl->next;
+ free(nl->filename);
+ free(nl);
+ }
+ return (-1);
+ }
+ strcat(strcat(strcpy(nl->filename, dir), "/"), de->d_name);
+ ++cnt;
+ nl->next=l;
+ l=nl;
+ }
+
+ if (dirp)
+ closedir(dirp);
+
+ if (!l)
+ {
+ errno=ENOENT;
+ return (-1);
+ }
+
+ if ((a=malloc(sizeof(char *)*cnt)) == NULL)
+ {
+ while ((nl=l) != NULL)
+ {
+ l=nl->next;
+ free(nl->filename);
+ free(nl);
+ }
+ return (-1);
+ }
+
+ cnt=0;
+ for (nl=l; nl; nl=nl->next)
+ a[cnt++]=nl->filename;
+
+ qsort(a, cnt, sizeof(*a), cmp_str);
+
+ fd= -1;
+
+ for (i=0; i<cnt; i++)
+ {
+ struct sockaddr_un skun;
+ int rc;
+
+ fd=socket(PF_UNIX, SOCK_STREAM, 0);
+ if (fd < 0)
+ break;
+
+ skun.sun_family=AF_UNIX;
+ strcpy(skun.sun_path, a[i]);
+
+ if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
+ {
+ close(fd);
+ fd= -1;
+ break;
+ }
+
+ if ( pcp->sockname )
+ free(pcp->sockname);
+ if ( (pcp->sockname=strdup(a[i])) == NULL)
+ {
+ close(fd);
+ fd= -1;
+ break;
+ }
+
+ if ( connect(fd,
+ (const struct sockaddr *)&skun,
+ sizeof(skun)) == 0)
+ {
+ /* That was easy, we're done. */
+
+ if (fcntl(fd, F_SETFL, 0) < 0)
+ {
+ close(fd);
+ fd= -1;
+ break;
+ }
+ }
+ else if ( errno != EINPROGRESS && errno != EWOULDBLOCK)
+ {
+ close(fd);
+ fd= -1;
+ break;
+ }
+ else
+ {
+ struct timeval tv;
+ fd_set fdr;
+ int rc;
+
+ FD_ZERO(&fdr);
+ FD_SET(fd, &fdr);
+ tv.tv_sec=30;
+ tv.tv_usec=0;
+
+ rc=select(fd+1, 0, &fdr, 0, &tv);
+ if (rc <= 0 || !FD_ISSET(fd, &fdr))
+ {
+ close(fd);
+ fd= -1;
+ break;
+ }
+
+ if ( connect(fd, (const struct sockaddr *)&skun,
+ sizeof(skun)))
+ {
+ if (errno != EISCONN)
+ {
+ close(fd);
+ break;
+ }
+ }
+
+ if (fcntl(fd, F_SETFL, 0) < 0)
+ {
+ close(fd);
+ break;
+ }
+ }
+
+ pcp->fd=fd;
+ if (docmd(pcp, "CAPABILITY\n", 0))
+ {
+ fd= -1;
+ break;
+ }
+
+ if ((rc=checkstatus(pcp, NULL)) != 100)
+ {
+ close(fd);
+ fd= -1;
+ continue;
+ }
+
+ if (!has100(pcp, "PCP1"))
+ {
+ close(fd);
+ fd= -1;
+ continue;
+ }
+
+ buf=malloc(strlen(username)+sizeof("USERID \n"));
+ if (buf == 0)
+ {
+ close(fd);
+ fd= -1;
+ break;
+
+ }
+
+ strcat(strcat(strcpy(buf, "USERID "), username), "\n");
+
+ if (docmd(pcp, buf, 0))
+ {
+ fd= -1;
+ free(buf);
+ break;
+ }
+ pcp->fd= -1;
+ free(buf);
+
+ switch ((rc=checkstatus(pcp, NULL)) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ errno=EIO;
+ if (errmsg)
+ {
+ if (*errmsg)
+ free(*errmsg);
+ *errmsg=strdup(pcp->readbuf);
+ }
+ close(fd);
+ fd= -1;
+ break;
+ case 5:
+ errno=ENOENT;
+ if (errmsg)
+ {
+ if (*errmsg)
+ free(*errmsg);
+ *errmsg=strdup("Calendar not found.");
+ }
+ close(fd);
+ fd= -1;
+ continue;
+ }
+
+ if (rc == 102)
+ {
+ if (parseauthtoken(pcp))
+ {
+ close(fd);
+ fd= -1;
+ }
+ break;
+ }
+ break;
+ }
+
+ free(a);
+ while ((nl=l) != NULL)
+ {
+ l=nl->next;
+ free(nl->filename);
+ free(nl);
+ }
+ return (fd);
+}
+
+static struct PCP *setcapabilities(struct PCPnet *, int);
+
+struct PCP *pcp_open_server(const char *username, const char *password,
+ char **errmsg)
+{
+ struct PCPnet *pcp=mkpcp(username);
+
+ if (errmsg)
+ *errmsg=0;
+ if (!pcp)
+ return (NULL);
+
+ if (strchr(username, '\r') || strchr(username, '\n'))
+ {
+ errno=EINVAL;
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if (strchr(password, '\r') || strchr(password, '\n'))
+ {
+ errno=EINVAL;
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+
+ if ((pcp->fd=doconnect(pcp, CALENDARDIR "/public", username, NULL,
+ NULL, errmsg)) < 0)
+ {
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if (pcp->authtoken == NULL)
+ {
+ char *buf;
+ int rc;
+
+ if (strchr(password, '\n') || strchr(password, '\r'))
+ {
+ errno=EINVAL;
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ buf=malloc(strlen(password)+sizeof("PASSWORD \n"));
+ if (buf == 0)
+ {
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ strcat(strcat(strcpy(buf, "PASSWORD "), password), "\n");
+
+ if (docmd(pcp, buf, 0))
+ {
+ free(buf);
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+ free(buf);
+
+ switch ((rc=checkstatus(pcp, NULL)) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ if (errmsg)
+ {
+ if (*errmsg)
+ free(*errmsg);
+ *errmsg=strdup(pcp->readbuf);
+ }
+ pcp_close_net(pcp);
+ errno=EPERM;
+ return (NULL);
+ }
+
+ if (rc == 102)
+ {
+ if (parseauthtoken(pcp))
+ {
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+ }
+ }
+
+ return (setcapabilities(pcp, 1));
+}
+
+static struct PCP *setcapabilities(struct PCPnet *pcp, int dofree)
+{
+ int rc;
+
+ if (docmd(pcp, "CAPABILITY\n", 0))
+ {
+ if (dofree)
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if ((rc=checkstatus(pcp, NULL)) != 100)
+ {
+ if (dofree)
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if (!has100(pcp, "PCP1"))
+ {
+ if (dofree)
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if (!has100(pcp, "ACL"))
+ {
+ pcp->pcp.acl_func=NULL;
+ pcp->pcp.listacl_func=NULL;
+ }
+ return ((struct PCP *)pcp);
+}
+
+struct PCP *pcp_find_proxy(const char *username,
+ const char *clustername,
+ char **errmsg)
+{
+ struct PCPnet *pcp=mkpcp(username);
+
+ if (errmsg)
+ *errmsg=0;
+ if (!pcp)
+ return (NULL);
+
+ if (strchr(username, '\r') || strchr(username, '\n'))
+ {
+ errno=EINVAL;
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if ((pcp->fd=doconnect(pcp, CALENDARDIR "/private", username, NULL,
+ clustername,
+ errmsg)) < 0)
+ {
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+ return ((struct PCP *)pcp);
+}
+
+int pcp_set_proxy(struct PCP *pcp_ptr, const char *proxy)
+{
+ struct PCPnet *pcp=(struct PCPnet *)pcp_ptr;
+ int rc;
+ char *p;
+
+ pcp->haserrmsg=0;
+
+ if (strchr(proxy, '\r') || strchr(proxy, '\n'))
+ {
+ errno=EINVAL;
+ return (-1);
+ }
+
+ p=malloc(strlen(proxy)+sizeof("PROXY \n"));
+
+ if (!p)
+ return (-1);
+
+ strcat(strcat(strcpy(p, "PROXY "), proxy), "\n");
+
+ if (docmd(pcp, p, 0))
+ {
+ free(p);
+ return (-1);
+ }
+
+ free(p);
+ switch ((rc=checkstatus(pcp, NULL)) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ return (-1);
+ }
+
+ if (setcapabilities(pcp, 0) == NULL)
+ return (-1);
+ return (0);
+}
+
+struct PCP *pcp_reopen_server(const char *username, const char *authtoken,
+ char **errmsg)
+{
+ struct PCPnet *pcp=mkpcp(username);
+ char *authtoken_cpy;
+ char *p, *q;
+
+ if (!pcp)
+ return (NULL);
+
+ /* auth token is: sockname/token */
+
+ if ((authtoken_cpy=strdup(authtoken)) == NULL)
+ {
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if ((p=strchr(authtoken_cpy, '/')) == NULL)
+ {
+ errno=EINVAL;
+ free(authtoken_cpy);
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ *p++=0;
+
+ for (q=p; *q; ++q)
+ if (isspace((int)(unsigned char)*q))
+ {
+ errno=EINVAL;
+ free(authtoken_cpy);
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if ((pcp->fd=doconnect(pcp, CALENDARDIR "/public", username,
+ authtoken_cpy, NULL, errmsg)) < 0)
+ {
+ free(authtoken_cpy);
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ if (pcp->authtoken == NULL)
+ {
+ char *buf;
+ int rc;
+
+ buf=malloc(strlen(p)+sizeof("RELOGIN \n"));
+ if (buf == 0)
+ {
+ free(authtoken_cpy);
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+
+ strcat(strcat(strcpy(buf, "RELOGIN "), p), "\n");
+ free(authtoken_cpy);
+
+ if (docmd(pcp, buf, 0))
+ {
+ free(buf);
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+ free(buf);
+
+ switch ((rc=checkstatus(pcp, NULL)) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ errno=EIO;
+ if (errmsg)
+ {
+ if (*errmsg)
+ free(*errmsg);
+ *errmsg=strdup(pcp->readbuf);
+ }
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+ if (rc == 102)
+ {
+ if (parseauthtoken(pcp))
+ {
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+ }
+ else /* Keeping the same token */
+ if ((pcp->authtoken=strdup(authtoken)) == NULL)
+ {
+ pcp_close_net(pcp);
+ return (NULL);
+ }
+ }
+ else
+ free(authtoken_cpy);
+
+ return (setcapabilities(pcp, 1));
+}
+
+static void pcp_close_quit_net(struct PCPnet *pcp)
+{
+ if (pcp->fd >= 0)
+ docmd(pcp, "QUIT\n", 0);
+ pcp_close_net(pcp);
+}
+
+static void pcp_close_net(struct PCPnet *pd)
+{
+ if (pd->fd >= 0)
+ close(pd->fd);
+ if (pd->sockname)
+ free(pd->sockname);
+ if (pd->authtoken)
+ free(pd->authtoken);
+ if (pd->readbuf)
+ free(pd->readbuf);
+ free(pd->username);
+ free(pd);
+}
+
+static int cleanup(struct PCPnet *pn)
+{
+ return (0);
+}
+
+static struct PCP_new_eventid *neweventid(struct PCPnet *pn,
+ const char *ev,
+ struct PCP_save_event *se)
+{
+ struct PCPnet_new_eventid *p;
+ char *q;
+ char rbuf[BUFSIZ], wbuf[BUFSIZ];
+ char *rbufptr;
+ int bufl;
+ char *wbufptr;
+ int wbufleft;
+ char *s;
+ unsigned new_len, n;
+
+ int seeneol;
+
+ pn->haserrmsg=0;
+ if (ev && (strchr(ev, '\n') || strchr(ev, '\r')))
+ {
+ errno=EINVAL;
+ return (NULL);
+ }
+
+ p=malloc(sizeof(struct PCPnet_new_eventid));
+ if (!p)
+ return (NULL);
+ memset(p, 0, sizeof(*p));
+
+ pn->haserrmsg=1;
+
+ if (docmd(pn, "RSET\n", 0))
+ {
+ free(p);
+ return (NULL);
+ }
+ switch (checkstatus(pn, NULL) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ free(p);
+ return (NULL);
+ }
+
+ if (docmd(pn, se->flags & PCP_OK_CONFLICT
+ ? "CONFLICT ON\n":"CONFLICT OFF\n", 0))
+ {
+ free(p);
+ errno=EINVAL;
+ return (NULL);
+ }
+
+ if (docmd(pn, se->flags & PCP_OK_PROXY_ERRORS
+ ? "FORCE ON\n":"FORCE OFF\n", 0))
+ {
+ free(p);
+ errno=EINVAL;
+ return (NULL);
+ }
+
+ if (ev)
+ {
+ pn->haserrmsg=0;
+ q=malloc(sizeof("DELETE \n")+strlen(ev));
+ if (!q)
+ {
+ free(p);
+ return (NULL);
+ }
+ pn->haserrmsg=1;
+ strcat(strcat(strcpy(q, "DELETE "), ev), "\n");
+ if (docmd(pn, q, 0))
+ {
+ free(q);
+ free(p);
+ return (NULL);
+ }
+ free(q);
+
+ switch (checkstatus(pn, NULL) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ free(p);
+ return (NULL);
+ }
+ }
+
+ new_len=30;
+ for (n=0; n<se->n_event_participants; n++)
+ {
+ const char *pp=se->event_participants[n].address;
+
+ if (pp)
+ {
+ if (strchr(pp, '\n') || strchr(pp, '\r'))
+ {
+ errno=EINVAL;
+ free(p);
+ return (NULL);
+ }
+
+ new_len += strlen(pp)+1;
+ }
+ }
+
+ if ((s=malloc(new_len)) == NULL)
+ {
+ free(p);
+ return (NULL);
+ }
+
+ strcpy(s, "NEW");
+
+ for (n=0; n<se->n_event_participants; n++)
+ {
+ const char *p=se->event_participants[n].address;
+
+ if (p)
+ strcat(strcat(s, " "), p);
+ }
+
+ strcat(s, "\n");
+
+ if (docmd(pn, s, 0))
+ {
+ free(s);
+ free(p);
+ return (NULL);
+ }
+ free(s);
+
+ if ((checkstatus(pn, NULL) / 100) != 3)
+ {
+ free(p);
+ return (NULL);
+ }
+
+ wbufptr=wbuf;
+ wbufleft=sizeof(wbuf);
+ seeneol=1;
+
+ while ((bufl=pcp_read_saveevent(se, rbuf, sizeof(rbuf))) > 0)
+ {
+ rbufptr=rbuf;
+
+ while (bufl)
+ {
+ if (seeneol && *rbufptr == '.')
+ {
+ if (!wbufleft)
+ {
+ if (dowrite(pn, wbuf, sizeof(wbuf)))
+ break;
+ wbufptr=wbuf;
+ wbufleft=sizeof(wbuf);
+ }
+ *wbufptr++='.';
+ --wbufleft;
+ }
+
+ if (!wbufleft)
+ {
+ if (dowrite(pn, wbuf, sizeof(wbuf)))
+ break;
+ wbufptr=wbuf;
+ wbufleft=sizeof(wbuf);
+ }
+
+ seeneol= *rbufptr == '\n';
+ *wbufptr++ = *rbufptr++;
+ --wbufleft;
+ --bufl;
+ }
+ }
+
+ if (bufl) /* Write error, flush things through */
+ {
+ if (bufl > 0)
+ while ((bufl=pcp_read_saveevent(se, rbuf,
+ sizeof(rbuf))) > 0)
+ ;
+ free(p);
+ return (NULL);
+ }
+
+ s=seeneol ? ".\n":"\n.\n";
+
+ while (*s)
+ {
+ if (!wbufleft)
+ {
+ if (dowrite(pn, wbuf, sizeof(wbuf)))
+ {
+ free(p);
+ return (NULL);
+ }
+ wbufptr=wbuf;
+ wbufleft=sizeof(wbuf);
+ }
+ *wbufptr++= *s++;
+ --wbufleft;
+ }
+
+ if (wbufptr > wbuf && dowrite(pn, wbuf, wbufptr-wbuf))
+ {
+ free(p);
+ return (NULL);
+ }
+
+ if (getfullreply(pn))
+ {
+ free(p);
+ return (NULL);
+ }
+
+ if (checkstatus(pn, NULL) != 109)
+ {
+ errno=EIO;
+ free(p);
+ return (NULL);
+ }
+
+ s=pn->readbuf;
+
+ getword(pn, &s); /* Skip 109 */
+
+ q=getword(pn, &s);
+ if (!q)
+ {
+ errno=EIO;
+ free(p);
+ return (NULL);
+ }
+ if ((p->eventid.eventid=strdup(q)) == NULL)
+ {
+ free(p);
+ return (NULL);
+ }
+ return (&p->eventid);
+}
+
+static void destroyeventid(struct PCPnet *pn, struct PCPnet_new_eventid *id)
+{
+ free(id->eventid.eventid);
+ free(id);
+}
+
+static int docommitevent2(struct PCPnet *pn, int *,
+ void (*)(const char *, const char *, void *),
+ void *);
+
+static int commitevent(struct PCPnet *pn, struct PCPnet_new_eventid *id,
+ struct PCP_commit *ci)
+{
+ if (!id->isbooked)
+ {
+ int rc=bookevent(pn, id, ci);
+
+ if (rc)
+ return (rc);
+ }
+
+ return (docommitevent2(pn, &ci->errcode, ci->proxy_callback,
+ ci->proxy_callback_ptr));
+}
+
+static int docommitevent2(struct PCPnet *pn, int *errcode,
+ void (*proxy_callback)(const char *,
+ const char *,
+ void *),
+ void *proxy_callback_ptr)
+{
+ int s;
+
+ pn->haserrmsg=0;
+
+ if (dowrite(pn, "COMMIT\n", 0))
+ return (-1);
+
+ pn->haserrmsg=1;
+
+ while ((s=getonelinereply(pn)) >= 0)
+ {
+ int n=checkstatus(pn, errcode);
+
+ if (n == 111)
+ {
+ char *p=pn->readbuf+3;
+ char *action;
+
+ if (*p)
+ ++p;
+
+
+ action=getword(pn, &p);
+
+ while (*p && isspace((int)(unsigned char)*p))
+ ++p;
+
+ if (proxy_callback)
+ (*proxy_callback)(action, p,
+ proxy_callback_ptr);
+ }
+
+ if (s > 0)
+ return ( (n / 100) < 4 ? 0:-1);
+ }
+ pn->haserrmsg=0;
+ return (-1);
+}
+
+static int docommitresponse(struct PCPnet *,
+ int (*)(const char *, time_t, time_t,
+ const char *, void *),
+ void *,
+ int *);
+
+static int bookevent(struct PCPnet *pn, struct PCPnet_new_eventid *id,
+ struct PCP_commit *ci)
+{
+ char *q;
+ unsigned i;
+ int ss;
+
+ ci->errcode=0;
+ pn->haserrmsg=0;
+
+ if (ci->n_event_times <= 0)
+ {
+ errno=EINVAL;
+ return (-1);
+ }
+
+ pn->haserrmsg=1;
+
+ switch (checkstatus(pn, NULL) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ return (-1);
+ }
+
+ /* yyyymmddhhmmss - 14 chars. Each time is <space>start-end */
+
+ pn->haserrmsg=0;
+
+ q=malloc(ci->n_event_times * 32 + 20); /* Eh, that's enough */
+
+ if (!q)
+ return (-1);
+
+ strcpy(q, "BOOK");
+
+ for (i=0; i<ci->n_event_times; i++)
+ {
+ char buf[15];
+
+ pcp_gmtimestr(ci->event_times[i].start, buf);
+ strcat(strcat(q, " "), buf);
+ pcp_gmtimestr(ci->event_times[i].end, buf);
+ strcat(strcat(q, "-"), buf);
+ }
+ strcat(q, "\n");
+
+ if (dowrite(pn, q, 0))
+ {
+ free(q);
+ return (-1);
+ }
+ free(q);
+
+ ss=docommitresponse(pn, ci->add_conflict_callback,
+ ci->add_conflict_callback_ptr,
+ &ci->errcode);
+
+ if (ss == 0)
+ id->isbooked=1;
+ return (ss);
+}
+
+static int docommitresponse(struct PCPnet *pn,
+ int (*conflict_func)(const char *, time_t, time_t,
+ const char *, void *),
+ void *callback_arg,
+ int *errcode)
+{
+ int s;
+ int rc=0;
+
+ pn->haserrmsg=0;
+
+ while ((s=getonelinereply(pn)) >= 0)
+ {
+ int ss=checkstatus(pn, errcode);
+
+ switch (ss / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ if (ss == 403)
+ {
+ char eventid[EVENTID_MAXLEN];
+ char from[15];
+ char to[15];
+ char addr[ADDR_MAXLEN];
+ char dummy;
+ time_t from_t, to_t;
+
+ if (sscanf(pn->readbuf,
+ "403%c" ADDR_SSCANF " %14s %14s "
+ EVENTID_SSCANF,
+ &dummy,
+ addr, from, to,
+ eventid)
+ != 5)
+ {
+ rc= -1;
+ return (-1);
+ }
+
+ from_t=pcp_gmtime_s(from);
+ to_t=pcp_gmtime_s(to);
+ if (!from_t || !to_t)
+ {
+ errno=EIO;
+ return (-1);
+ }
+
+ if (rc == 0 && conflict_func)
+ rc= (*conflict_func)
+ (eventid, from_t, to_t, addr,
+ callback_arg);
+ if (errcode)
+ *errcode=PCP_ERR_CONFLICT;
+ }
+ rc= -1;
+ }
+ pn->haserrmsg=1;
+ if (s > 0)
+ break;
+ pn->haserrmsg=0;
+ }
+
+ return (rc);
+}
+
+static int parse105(struct PCPnet *pn, time_t *from_t, time_t *to_t,
+ char eventid[EVENTID_MAXLEN])
+{
+ char dummy;
+ char from[15];
+ char to[15];
+
+ if (sscanf(pn->readbuf, "105%c" EVENTID_SSCANF " %14s %14s",
+ &dummy, eventid, from, to) == 4)
+ {
+ if ((*from_t=pcp_gmtime_s(from)) &&
+ (*to_t=pcp_gmtime_s(to)))
+ return (0);
+ }
+ errno=EIO;
+ return (-1);
+}
+
+static int listallevents(struct PCPnet *pn, struct PCP_list_all *la)
+{
+ char cmdbuf[100];
+ int rc, s;
+
+ strcpy(cmdbuf, "LIST");
+
+ if (la->list_from || la->list_to)
+ {
+ char buf[15];
+
+ strcat(cmdbuf, " FROM ");
+ if (la->list_from)
+ {
+ pcp_gmtimestr(la->list_from, buf);
+ strcat(cmdbuf, buf);
+ }
+ strcat(cmdbuf, "-");
+ if (la->list_to)
+ {
+ pcp_gmtimestr(la->list_to, buf);
+ strcat(cmdbuf, buf);
+ }
+ }
+
+ strcat(cmdbuf, "\n");
+
+ pn->haserrmsg=0;
+ if (dowrite(pn, cmdbuf, 0) < 0)
+ return (-1);
+
+ rc=0;
+ pn->haserrmsg=1;
+
+ while ((s=getonelinereply(pn)) >= 0)
+ {
+ int n=checkstatus(pn, NULL);
+ if (n >= 400)
+ rc= -1;
+ if (n == 105)
+ {
+ char eventid[EVENTID_MAXLEN];
+
+ if (parse105(pn, &la->event_from, &la->event_to,
+ eventid) == 0)
+ {
+ la->event_id=eventid;
+ if (rc == 0)
+ rc= (*la->callback_func)
+ (la, la->callback_arg);
+ }
+ }
+ if (s > 0)
+ break;
+ }
+
+ if (s < 0)
+ {
+ pn->haserrmsg=0;
+ rc= -1;
+ }
+ return (rc);
+}
+
+static int cancelevent(struct PCPnet *pn, const char *id, int *errcode)
+{
+ char *buf;
+
+ if (errcode)
+ *errcode=0;
+
+ pn->haserrmsg=0;
+
+ if (strchr(id, '\r') || strchr(id, '\n'))
+ {
+ errno=EINVAL;
+ return (-1);
+ }
+
+ buf=malloc(strlen(id)+20);
+ if (!buf)
+ return (-1);
+
+ strcat(strcat(strcpy(buf, "CANCEL "), id), "\n");
+ if (docmd(pn, buf, 0))
+ {
+ free(buf);
+ return (-1);
+ }
+ pn->haserrmsg=1;
+
+ switch (checkstatus(pn, errcode) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ return (-1);
+ }
+ return (0);
+}
+
+static int uncancelevent(struct PCPnet *pn, const char *id,
+ int flags, struct PCP_uncancel *ui)
+{
+ char *buf;
+
+ pn->haserrmsg=0;
+ if (ui)
+ ui->errcode=0;
+
+ if (strchr(id, '\r') || strchr(id, '\n'))
+ {
+ errno=EINVAL;
+ return (-1);
+ }
+ if (docmd(pn, "RSET\n", 0))
+ return (-1);
+ pn->haserrmsg=1;
+
+ switch (checkstatus(pn, NULL) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ return (-1);
+ }
+
+ pn->haserrmsg=0;
+ if (docmd(pn, flags & PCP_OK_CONFLICT
+ ? "CONFLICT ON\n":"CONFLICT OFF\n", 0))
+ {
+ return (-1);
+ }
+ if (docmd(pn, flags & PCP_OK_PROXY_ERRORS
+ ? "FORCE ON\n":"FORCE OFF\n", 0))
+ {
+ return (-1);
+ }
+
+ pn->haserrmsg=1;
+
+ switch (checkstatus(pn, NULL) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ return (-1);
+ }
+
+ buf=malloc(strlen(id)+20);
+ if (!buf)
+ return (-1);
+
+ strcat(strcat(strcpy(buf, "UNCANCEL "), id), "\n");
+ if (dowrite(pn, buf, 0))
+ {
+ free(buf);
+ return (-1);
+ }
+
+ return (docommitresponse(pn, ui ? ui->uncancel_conflict_callback:NULL,
+ ui ? ui->uncancel_conflict_callback_ptr:NULL,
+ ui ? &ui->errcode:NULL));
+}
+
+static int deleteevent(struct PCPnet *pn,
+ struct PCP_delete *del)
+{
+ char *buf;
+
+ pn->haserrmsg=0;
+ del->errcode=0;
+
+ if (strchr(del->id, '\r') || strchr(del->id, '\n'))
+ {
+ errno=EINVAL;
+ return (-1);
+ }
+ if (docmd(pn, "RSET\n", 0))
+ return (-1);
+ pn->haserrmsg=1;
+
+ switch (checkstatus(pn, NULL) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ return (-1);
+ }
+ pn->haserrmsg=0;
+
+ buf=malloc(strlen(del->id)+20);
+ if (!buf)
+ return (-1);
+
+ strcat(strcat(strcpy(buf, "DELETE "), del->id), "\n");
+ if (docmd(pn, buf, 0))
+ {
+ free(buf);
+ return (-1);
+ }
+
+ pn->haserrmsg=1;
+
+ switch (checkstatus(pn, &del->errcode) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ return (-1);
+ }
+
+ return (docommitevent2(pn, &del->errcode,
+ del->proxy_callback,
+ del->proxy_callback_ptr));
+}
+
+static int retr_105(struct PCPnet *, struct PCP_retr *);
+static int retr_106(struct PCPnet *, struct PCP_retr *);
+static int retr_110(struct PCPnet *, struct PCP_retr *);
+static int retr_107(struct PCPnet *, struct PCP_retr *, int);
+
+static int retrevent(struct PCPnet *pn, struct PCP_retr *ri)
+{
+ char items_buf[256];
+ unsigned i;
+ size_t cnt;
+ char *q;
+ int errflag;
+
+ items_buf[0]=0;
+ pn->haserrmsg=0;
+
+ if (ri->callback_retr_status)
+ strcat(items_buf, " STATUS");
+ if (ri->callback_retr_date)
+ strcat(items_buf, " DATE");
+ if (ri->callback_retr_participants)
+ strcat(items_buf, " ADDR");
+ if (ri->callback_rfc822_func)
+ strcat(items_buf, " TEXT");
+ else if (ri->callback_headers_func)
+ strcat(items_buf, " HEADERS");
+
+ if (items_buf[0] == 0)
+ {
+ errno=EIO;
+ return (-1);
+ }
+
+ cnt=strlen(items_buf)+256;
+
+ for (i=0; ri->event_id_list[i]; i++)
+ {
+ const char *p=ri->event_id_list[i];
+
+ if (strchr(p, '\n'))
+ {
+ errno=EIO;
+ return (-1);
+ }
+ cnt += 1 + strlen(p);
+ }
+
+ q=malloc(cnt);
+
+ if (!q)
+ return (-1);
+
+ strcat(strcat(strcpy(q, "RETR"), items_buf), " EVENTS");
+
+ for (i=0; ri->event_id_list[i]; i++)
+ {
+ strcat(strcat(q, " "), ri->event_id_list[i]);
+ }
+ strcat(q, "\n");
+
+ if (dowrite(pn, q, 0) < 0)
+ {
+ free(q);
+ return (-1);
+ }
+ free(q);
+
+ errflag=0;
+
+ for (;;)
+ {
+ int rc;
+
+ if (!errflag)
+ pn->haserrmsg=0;
+ if (getfullreply(pn) < 0)
+ return (-1);
+
+ if (!errflag)
+ pn->haserrmsg=1;
+ rc=checkstatus(pn, NULL);
+
+ if ( rc < 100 || rc >= 400)
+ return (-1);
+ if (rc == 108)
+ break;
+ pn->haserrmsg=0;
+
+ switch (rc) {
+ case 105:
+ if (errflag)
+ break;
+ rc=retr_105(pn, ri);
+ if (rc)
+ errflag=rc;
+ break;
+ case 106:
+ if (errflag)
+ break;
+ rc=retr_106(pn, ri);
+ if (rc)
+ errflag=rc;
+ break;
+ case 110:
+ if (errflag)
+ break;
+ rc=retr_110(pn, ri);
+ if (rc)
+ errflag=rc;
+ break;
+ case 107:
+ rc=retr_107(pn, ri, errflag);
+ if (!errflag && rc)
+ errflag=rc;
+ break;
+ default:
+ close(pn->fd);
+ pn->fd= -1;
+ errno=EIO;
+ return (-1);
+ }
+ }
+
+ return (errflag);
+}
+
+static int retr_105(struct PCPnet *pn, struct PCP_retr *ri)
+{
+ char eventid[EVENTID_MAXLEN];
+ time_t from_t, to_t;
+
+ if (parse105(pn, &from_t, &to_t, eventid) == 0)
+ {
+ ri->event_id=eventid;
+
+ if (ri->callback_retr_date)
+ return ( (*ri->callback_retr_date)
+ (ri, from_t, to_t, ri->callback_arg));
+ }
+
+ return (0);
+}
+
+static int retr_106(struct PCPnet *pn, struct PCP_retr *ri)
+{
+ char dummy;
+ char eventid[EVENTID_MAXLEN];
+ char addr[ADDR_MAXLEN];
+
+ if (sscanf(pn->readbuf, "106%c" EVENTID_SSCANF " " ADDR_SSCANF,
+ &dummy, eventid, addr) == 3)
+ {
+ ri->event_id=eventid;
+
+ if (ri->callback_retr_participants)
+ return ( (*ri->callback_retr_participants)
+ (ri, addr, NULL, ri->callback_arg));
+ }
+
+ return (0);
+}
+
+static int retr_110(struct PCPnet *pn, struct PCP_retr *ri)
+{
+ char dummy;
+ char eventid[EVENTID_MAXLEN];
+
+ if (sscanf(pn->readbuf, "110%c" EVENTID_SSCANF,
+ &dummy, eventid) == 2)
+ {
+ const char *p, *q;
+ char *r, *s;
+ int flags=0;
+
+ ri->event_id=eventid;
+
+ p=pn->readbuf+4;
+ while (p)
+ {
+ if (isspace((int)(unsigned char)*p))
+ break;
+ ++p;
+ }
+
+ while (p)
+ {
+ if (!isspace((int)(unsigned char)*p))
+ break;
+ ++p;
+ }
+
+ for (q=p; *q; q++)
+ {
+ if (isspace((int)(unsigned char)*q))
+ break;
+ }
+ r=malloc(q-p+1);
+ if (!r)
+ {
+ pn->haserrmsg=0;
+ return (-1);
+ }
+ memcpy(r, p, q-p);
+ r[q-p]=0;
+
+ for (s=r; (s=strtok(s, ",")) != 0; s=0)
+ {
+ if (strcasecmp(s, "CANCELLED") == 0)
+ flags |= LIST_CANCELLED;
+ else if (strcasecmp(s, "BOOKED") == 0)
+ flags |= LIST_BOOKED;
+ else if (strcasecmp(s, "PROXY") == 0)
+ flags |= LIST_PROXY;
+ }
+
+
+ if (ri->callback_retr_status)
+ return ( (*ri->callback_retr_status)
+ (ri, flags, ri->callback_arg));
+ }
+
+ return (0);
+}
+
+static int retr_107(struct PCPnet *pn, struct PCP_retr *ri, int ignore)
+{
+ char dummy;
+ char eventid[EVENTID_MAXLEN];
+ int rc=0;
+ int ch;
+ int seeneol;
+ int seendot;
+ size_t nn;
+
+ if (sscanf(pn->readbuf, "107%c" EVENTID_SSCANF,
+ &dummy, eventid) != 2)
+ {
+ errno=EIO;
+ rc= -1;
+ }
+
+ ri->event_id=eventid;
+
+ if (rc == 0 && ri->callback_begin_func)
+ rc= (*ri->callback_begin_func)(ri, ri->callback_arg);
+
+ seeneol=1;
+ seendot=1;
+ nn=0;
+
+ ch=EOF;
+ for (;;)
+ {
+ if (ch == EOF)
+ ch=readch(pn, nn);
+ if (ch == EOF)
+ {
+ rc= -1;
+ break;
+ }
+ if (ch == '\r')
+ continue;
+
+ if (seeneol)
+ seendot= ch == '.';
+ else
+ {
+ if ( ch == '\n' && seendot)
+ break;
+ seendot=0;
+ }
+ seeneol= ch == '\n';
+
+ if (!seendot)
+ pn->readbuf[nn++]=ch;
+ ch=EOF;
+
+ if (ri->callback_rfc822_func)
+ {
+ if (nn >= 8192)
+ {
+ if (rc == 0)
+ rc= (*ri->callback_rfc822_func)
+ (ri, pn->readbuf, nn,
+ ri->callback_arg);
+ nn=0;
+ }
+ }
+ else if (ri->callback_headers_func)
+ {
+ if (nn > 8192)
+ nn=8192; /* Trim excessive hdrs */
+
+ if (seeneol)
+ {
+ char *h;
+ char *v;
+
+ ch=readch(pn, nn);
+ if (ch == EOF)
+ {
+ rc= -1;
+ break;
+ }
+
+ if (ch != '\n' && isspace(ch))
+ {
+ /* Header wrapped */
+
+ while (ch != EOF && ch != '\n'
+ && isspace(ch))
+ ch=readch(pn, nn);
+ pn->readbuf[nn-1]=' ';
+ continue;
+ }
+ pn->readbuf[nn-1]=0;
+ h=pn->readbuf;
+ if ((v=strchr(h, ':')) == NULL)
+ v="";
+ else
+ {
+ *v++=0;
+ while (*v &&
+ isspace((int)(unsigned char)*v))
+ ++v;
+ }
+ if (rc == 0)
+ rc=(*ri->callback_headers_func)
+ (ri, h, v, ri->callback_arg);
+ nn=0;
+ }
+ }
+ else nn=0;
+ }
+
+ if (ri->callback_rfc822_func)
+ {
+ if (rc == 0)
+ rc= (*ri->callback_rfc822_func)
+ (ri, pn->readbuf, nn, ri->callback_arg);
+ }
+
+ if (rc == 0 && ri->callback_end_func)
+ rc= (*ri->callback_end_func)(ri, ri->callback_arg);
+ return (rc);
+}
+
+
+static int setacl(struct PCPnet *pn, const char *who, int flags)
+{
+ char buf[1024];
+
+ pn->haserrmsg=0;
+ if (strchr(who, '\r') || strchr(who, '\n') || strlen(who) > 512)
+ {
+ errno=EINVAL;
+ return (-1);
+ }
+
+ sprintf(buf, "ACL SET %s", who);
+ pcp_acl_name(flags, buf);
+ strcat(buf, "\n");
+
+ if (docmd(pn, buf, 0))
+ return (-1);
+ pn->haserrmsg=1;
+ switch (checkstatus(pn, NULL) / 100) {
+ case 1:
+ case 2:
+ case 3:
+ break;
+ default:
+ errno=EIO;
+ return (-1);
+ }
+ return (0);
+}
+
+
+static int listacl(struct PCPnet *pn, int (*func)(const char *, int, void *),
+ void *arg)
+{
+ int rc;
+ int s;
+
+ pn->haserrmsg=0;
+ if (dowrite(pn, "ACL LIST\n", 0) < 0)
+ return (-1);
+
+ rc=0;
+ pn->haserrmsg=1;
+
+ while ((s=getonelinereply(pn)) >= 0)
+ {
+ int n=checkstatus(pn, NULL);
+ if (n >= 400)
+ rc= -1;
+ if (n == 103)
+ {
+ char addr[ADDR_MAXLEN];
+ char dummy;
+
+ if (sscanf(pn->readbuf, "103%c" ADDR_SSCANF,
+ &dummy, addr) == 2)
+ {
+ const char *p=pn->readbuf+4;
+ int flags=0;
+
+ for ( ; *p; p++)
+ if (isspace((int)(unsigned char)*p))
+ break;
+
+ while (*p)
+ {
+ const char *q;
+ char buf[256];
+
+ if (isspace((int)(unsigned char)*p))
+ {
+ ++p;
+ continue;
+ }
+ q=p;
+
+ for ( ; *p; p++)
+ if (isspace((int)
+ (unsigned char)*p))
+ break;
+ buf[0]=0;
+ strncat(buf, q, p-q < 255 ? p-q:255);
+
+ flags |= pcp_acl_num(buf);
+ }
+
+ if (rc == 0)
+ rc= (*func)(addr, flags, arg);
+ }
+ else
+ {
+ if (rc == 0)
+ {
+ rc= -1;
+ errno=EIO;
+ }
+ }
+ }
+ if (s > 0)
+ break;
+ }
+
+ if (s < 0)
+ {
+ pn->haserrmsg=0;
+ rc= -1;
+ }
+ return (rc);
+}
+
+static void noop(struct PCPnet *pd)
+{
+ docmd(pd, "NOOP\n", 0);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-31 11:15:25 +0000