Back to index

courier  0.68.2
Classes | Defines | Functions | Variables
pcp.c File Reference
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <langinfo.h>
#include <fcntl.h>
#include <locale.h>
#include <libintl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <pwd.h>
#include <rfc822/rfc822.h>
#include <rfc822/rfc2047.h>
#include <rfc822/rfc822hdr.h>
#include <rfc2045/rfc2045.h>
#include <rfc2045/rfc2045charset.h>
#include <unicode/unicode.h>
#include <numlib/numlib.h>
#include "pcp.h"
#include "calendardir.h"

Go to the source code of this file.

Classes

struct  event_time_list
struct  participant_list
struct  add_info
struct  listinfo
struct  listinfo_index
struct  xretrinfo
struct  xretr_participant_list
struct  xretr_time_list

Defines

#define PCP_ERRMSG(s)   gettext(s)
#define FLAG_LIST_EVENT_ID   1

Functions

void rfc2045_enomem ()
static PCP_STRERROR time_t parse_datetime (int *argn, int argc, char **argv)
static const char * from_s ()
static const char * to_s ()
static const char * event_s ()
static const char * on_s ()
static void error (struct PCP *pcp, int n, const char *s)
static int save_time (time_t start, time_t end, void *vp)
static void usage ()
static struct passwd * do_getpw ()
struct PCPopen_calendar ()
static int add_info_callback (char *, int, void *)
static int show_conflict (const char *event_id, time_t from, time_t to, const char *addr, void *dummy)
static void add (int argn, int argc, char **argv, int flags, const char *old, struct add_info *add_info)
static int add_read_stdin (struct add_info *p)
static int add_read_stdin_prompt (struct add_info *p)
static int add_read_mime (struct add_info *p)
static int add_read_subject (struct add_info *p)
static int list_callback_saveindex (struct PCP_list_all *, void *)
static int indexcmp (const void *a, const void *b)
static void doretr (const char *)
static int save_retr_headers (struct PCP_retr *, const char *, const char *, void *)
static int save_retr_status (struct PCP_retr *, int, void *)
static void dump_rfc822_hdr (const char *ptr, size_t cnt, void *dummy)
static void list (int argn, int argc, char **argv, int flags)
static int doretr_begin (struct PCP_retr *r, void *vp)
static int doretr_save (struct PCP_retr *, const char *, int, void *)
static int do_show_retr (struct PCP_retr *, void *)
static int doretr_status (struct PCP_retr *p, int status, void *vp)
static int doretr_date (struct PCP_retr *p, time_t from, time_t to, void *vp)
static int doretr_participants (struct PCP_retr *p, const char *n, const char *id, void *vp)
static int tcmp (const void *a, const void *b)
static int list_msg_rfc822 (struct rfc2045 *, FILE *)
static int list_msg_mime (struct rfc2045 *, FILE *)
static int list_msg_rfc822_part (struct rfc2045 *rfc, FILE *fp)
static int list_msg_mime_multipart (struct rfc2045 *, FILE *)
static int list_msg_mime_multipart_alternative (struct rfc2045 *, FILE *)
static int list_msg_textplain (struct rfc2045 *, FILE *)
static int textplain_output (const char *ptr, size_t cnt, void *voidptr)
static void docancel (const char *id, int flags)
static void dodelete (const char *id, int flags)
static void douncancel (const char *id, int flags)
static void init (const char *shell)
static void login (const char *userid)
static void setacl (const char *who, int flags)
static int do_list_acl (const char *who, int flags, void *dummy)
static void listacls ()
static int doconnect (const char *pathname)
static void doconnectwrite (int, const char *, int)
static void doconnectloop (int fd)
static char * read_subject ()
static char * mimeify (const char *subject, const char *charset)
int main (int argc, char **argv)

Variables

static const char * charset = RFC2045CHARSET
static int(*)(struct rfc2045
*, FILE *) 
mime_handler (struct rfc2045 *rfc)

Class Documentation

struct event_time_list

Definition at line 96 of file pcp.c.

Collaboration diagram for event_time_list:
Class Members
struct event_time_list * next
struct participant_list

Definition at line 125 of file pcp.c.

Collaboration diagram for participant_list:
Class Members
char * address
struct participant_list * next
struct listinfo

Definition at line 543 of file pcp.c.

Collaboration diagram for listinfo:
Class Members
int cnt
const char * default_key
unsigned i_cnt
struct listinfo_index * index_list
int issecret
const char * list_event_id
time_t list_from
time_t list_to
struct listinfo_index

Definition at line 552 of file pcp.c.

Collaboration diagram for listinfo_index:
Class Members
char * eventid
size_t from
struct listinfo_index * next
int status
char * subject
size_t to
struct xretrinfo

Definition at line 904 of file pcp.c.

Collaboration diagram for xretrinfo:
Class Members
struct xretr_participant_list * participant_list
int status
struct xretr_time_list * time_list
FILE * tmpfile
struct xretr_participant_list

Definition at line 912 of file pcp.c.

Collaboration diagram for xretr_participant_list:
Class Members
struct xretr_participant_list * next
char * participant
struct xretr_time_list

Definition at line 917 of file pcp.c.

Collaboration diagram for xretr_time_list:
Class Members
time_t from
struct xretr_time_list * next
time_t to

Define Documentation

#define FLAG_LIST_EVENT_ID   1

Definition at line 40 of file pcp.c.

#define PCP_ERRMSG (   s)    gettext(s)

Definition at line 35 of file pcp.c.


Function Documentation

static void add ( int  argn,
int  argc,
char **  argv,
int  flags,
const char *  old,
struct add_info add_info 
) [static]

Definition at line 299 of file pcp.c.

{
       struct event_time_list *list=NULL;
       struct participant_list *book=NULL;

       const char *subject=NULL;
       struct PCP *pcp;
       struct PCP_new_eventid *nei;
       struct PCP_commit commit_info;
       struct PCP_save_event add_event_info;

       while (argn < argc)
       {
              if (strcmp(argv[argn], gettext("with")) == 0)
              {
                     struct participant_list **ptr;

                     ++argn;
                     if (argn >= argc)
                            usage();

                     for (ptr= &book; *ptr; ptr= &(*ptr)->next)
                            ;

                     if ((*ptr=malloc(sizeof(struct participant_list)))
                         == NULL)
                     {
                            perror("malloc");
                            exit(1);
                     }
                     (*ptr)->participant.address=argv[argn];
                     (*ptr)->next=NULL;
                     ++argn;
                     continue;
              }

              if (strcasecmp(argv[argn], from_s()) == 0)
              {
                     time_t from_time, to_time;

                     ++argn;
                     if ((from_time=parse_datetime(&argn, argc, argv))
                         == 0)
                            usage();

                     if (argn < argc && strcasecmp(argv[argn], to_s()) == 0)
                     {
                            ++argn;
                            if ((to_time=parse_datetime(&argn, argc,
                                                     argv)) == 0)
                                   usage();

                            if (from_time > to_time)
                                   usage();
                     }
                     else
                     {
                            to_time=from_time + 60 * 60;
                     }

                     if (argn < argc && strcmp(argv[argn],
                                            gettext("until")) == 0)
                     {
                            ++argn;

                            if (pcp_parse_datetime_until(from_time,
                                                      to_time,
                                                      &argn,
                                                      argc,
                                                      argv,

                                                      PCP_RECURRING_WEEKLY,
                                                      &save_time,
                                                      &list))
                                   usage();
                     }
                     else
                     {
                            save_time(from_time, to_time, &list);
                     }
                     continue;
              }

              if (strcmp(argv[argn], "subject") == 0)
              {
                     if (subject || ++argn >= argc)
                            usage();
                     subject=argv[argn++];
                     continue;
              }
              usage();
       }

       memset(&commit_info, 0, sizeof(commit_info));
       commit_info.flags=flags;

       {
              struct event_time_list *p;
              struct PCP_event_time *q=0;

              for (p=list; p; p=p->next)
                     ++commit_info.n_event_times;

              if (!commit_info.n_event_times)
                     usage();

              if ((commit_info.event_times=q=
                   calloc(commit_info.n_event_times,
                         sizeof(*commit_info.event_times))) == NULL)
              {
                     perror("malloc");
                     exit(1);
              }
              commit_info.n_event_times=0;
              for (p=list; p; p=p->next)
                     q[commit_info.n_event_times++]=p->thetime;
       }

       memset(&add_event_info, 0, sizeof(add_event_info));
       {
              struct participant_list *p;
              struct PCP_event_participant *q=0;

              for (p=book; p; p=p->next)
                     ++add_event_info.n_event_participants;

              if (add_event_info.n_event_participants &&
                  (add_event_info.event_participants=q=
                   calloc(add_event_info.n_event_participants,
                         sizeof(*add_event_info.event_participants)))
                  == NULL)
              {
                     perror("malloc");
                     exit(1);
                     return;
              }
              add_event_info.n_event_participants=0;

              for (p=book; p; p=p->next)
                     q[add_event_info.n_event_participants++]
                            =p->participant;
       }

       add_event_info.write_event_func=add_info_callback;
       add_event_info.write_event_func_misc_ptr=add_info;

       pcp=open_calendar();

       nei=pcp_new_eventid(pcp, old, &add_event_info);

       if (!nei)
       {
              pcp_close(pcp);
              perror("pcp_new_event_id");
              exit(1);
       }

       commit_info.add_conflict_callback= &show_conflict;
       if (pcp_commit(pcp, nei, &commit_info))
       {
              error(pcp, commit_info.errcode, "pcp_commit");
              pcp_destroy_eventid(pcp, nei);
              pcp_close(pcp);
              exit(1);
       }

       printf(gettext("Created event %s\n"), nei->eventid);
       pcp_destroy_eventid(pcp, nei);
       pcp_close(pcp);
       exit (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int add_info_callback ( char *  buf,
int  cnt,
void *  p 
) [static]

Definition at line 472 of file pcp.c.

{
       struct add_info *ai=(struct add_info *)p;
       int n;

       if (!ai->bufleft)
       {
              n= (*ai->add_func)(ai);

              if (n < 0)
                     return (n);
       }
       n=0;
       while (cnt && ai->bufleft)
       {
              *buf++ = *ai->bufptr++;
              --ai->bufleft;
              --cnt;
              ++n;
       }
       return (n);
}

Here is the caller graph for this function:

static int add_read_mime ( struct add_info p) [static]

Definition at line 527 of file pcp.c.

{
       strcpy(p->buffer, "Mime-Version: 1.0\n"
              "Content-Type: text/plain; charset=\"");
       strcat(p->buffer, p->add_charset);
       strcat(p->buffer, "\"\nContent-Transfer-Encoding: 8bit\n\n");
       p->add_func= add_read_stdin_prompt;
       p->bufptr=p->buffer;
       p->bufleft=strlen(p->buffer);
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int add_read_stdin ( struct add_info p) [static]

Definition at line 495 of file pcp.c.

{
       int n=read(0, p->buffer, sizeof(p->buffer));

       p->bufptr=p->buffer;
       if (n < 0)
              return (n);
       p->bufleft=n;
       return (0);
}

Here is the caller graph for this function:

static int add_read_stdin_prompt ( struct add_info p) [static]

Definition at line 506 of file pcp.c.

{
       p->add_func=add_read_stdin;

       printf(gettext("\nEnter event information, terminate with EOF (usually CTRL-D)\n\n"));
       return (add_read_stdin(p));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int add_read_subject ( struct add_info p) [static]

Definition at line 516 of file pcp.c.

{
       strcpy(p->buffer, "Subject: ");
       strncat(p->buffer, p->add_subject, sizeof(p->buffer)-100);
       strcat(p->buffer, "\n");
       p->add_func= &add_read_mime;
       p->bufptr=p->buffer;
       p->bufleft=strlen(p->buffer);
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct passwd* do_getpw ( ) [static, read]

Definition at line 132 of file pcp.c.

{
       struct passwd *pw=getpwuid(getuid());

       if (!pw)
       {
              perror("getpwuid");
              exit(1);
       }
       return(pw);
}

Here is the caller graph for this function:

static int do_list_acl ( const char *  who,
int  flags,
void *  dummy 
) [static]

Definition at line 1502 of file pcp.c.

{
       char buf[1024];

       buf[0]=0;
       pcp_acl_name(flags, buf);

       printf("%-30s\t%s\n", who, buf);
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int do_show_retr ( struct PCP_retr r,
void *  vp 
) [static]

Definition at line 1061 of file pcp.c.

{
       struct xretrinfo *xr=(struct xretrinfo *)vp;
       struct xretr_participant_list *p;
       struct xretr_time_list *t, **tt;
       unsigned cnt, i;
       struct rfc2045 *rfcp;
       int rc;

       if (fseek(xr->tmpfile, 0L, SEEK_SET) < 0
           || lseek(fileno(xr->tmpfile), 0L, SEEK_SET) < 0)
       {
              fclose(xr->tmpfile);
              return (-1);
       }

       if (xr->time_list == NULL)
       {
              fclose(xr->tmpfile);
              return (0);
       }

       printf(gettext("Event: %s\n"), r->event_id);

       for (cnt=0, t=xr->time_list; t; t=t->next)
              ++cnt;

       tt=(struct xretr_time_list **)malloc(cnt * sizeof(*t));
       if (!tt)
       {
              fclose(xr->tmpfile);
              return (-1);
       }

       for (cnt=0, t=xr->time_list; t; t=t->next)
              tt[cnt++]=t;

       qsort(tt, cnt, sizeof(*tt), tcmp);

       for (i=0; i<cnt; i++)
       {
              char fromto[500];

              if (pcp_fmttimerange(fromto, sizeof(fromto),
                                 tt[i]->from, tt[i]->to) < 0)
                     strcpy(fromto, "******");
              printf(gettext("       %s\n"), fromto);
       }
       free(tt);

       if (xr->status & LIST_CANCELLED)
              printf(gettext("    **** CANCELLED ****\n"));
       if (xr->status & LIST_BOOKED)
              printf(gettext("    **** EVENT NOT YET COMMITED ****\n"));

       for (p=xr->participant_list; p; p=p->next)
              printf(gettext("    Participant: %s\n"), p->participant);


       rfcp=rfc2045_fromfp(xr->tmpfile);
       if (!rfcp)
       {
              fclose(xr->tmpfile);
              return (-1);
       }

       rc=list_msg_rfc822(rfcp, xr->tmpfile);
       rfc2045_free(rfcp);
       fclose(xr->tmpfile);
       return (rc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void docancel ( const char *  id,
int  flags 
) [static]

Definition at line 1340 of file pcp.c.

{
       struct PCP *pcp=open_calendar();
       int errcode;

       if (pcp_cancel(pcp, id, &errcode))
       {
              error(pcp, errcode, "pcp_cancel");
              exit(1);
       }
       pcp_close(pcp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int doconnect ( const char *  pathname) [static]

Definition at line 1534 of file pcp.c.

{
        int     fd=socket(PF_UNIX, SOCK_STREAM, 0);
        struct  sockaddr_un skun;

       skun.sun_family=AF_UNIX;
        strcpy(skun.sun_path, pathname);

       if (fd >= 0 && fcntl(fd, F_SETFL, O_NONBLOCK) >= 0)
       {
              if (connect(fd, (struct sockaddr *)&skun, sizeof(skun)) == 0)
                     return (fd);

              if (errno == EINPROGRESS || errno == EWOULDBLOCK)
              {
                     struct timeval tv;
                     fd_set fds;
                     int rc;

                     tv.tv_sec=10;
                     tv.tv_usec=0;
                     FD_ZERO(&fds);
                     FD_SET(fd, &fds);

                     rc=select(fd+1, NULL, &fds, NULL, &tv);

                     if (rc > 1 && FD_ISSET(fd, &fds))
                     {
                            if (connect(fd, (struct sockaddr *)&skun,
                                       sizeof(skun)) == 0)
                                   return (fd);
                            if (errno == EISCONN)
                                   return (fd);
                     }

                     if (rc >= 0)
                            errno=ETIMEDOUT;
              }
       }
       perror(pathname);
       exit(1);
       return (0);
}

Here is the caller graph for this function:

static void doconnectloop ( int  fd) [static]

Definition at line 1580 of file pcp.c.

{
       char buf[BUFSIZ];
       fd_set rfd;

       for (;;)
       {
              FD_ZERO(&rfd);
              FD_SET(0, &rfd);
              FD_SET(fd, &rfd);

              if (select(fd+1, &rfd, NULL, NULL, NULL) <= 0)
              {
                     perror("select");
                     continue;
              }

              if (FD_ISSET(fd, &rfd))
              {
                     int n=read(fd, buf, sizeof(buf));

                     if (n < 0)
                            perror("read");
                     if (n <= 0)
                            break;
                     doconnectwrite(1, buf, n);
              }

              if (FD_ISSET(0, &rfd))
              {
                     int n=read(0, buf, sizeof(buf));

                     if (n < 0)
                            perror("read");
                     if (n <= 0)
                            break;
                     doconnectwrite(fd, buf, n);
              }
       }
       exit(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void doconnectwrite ( int  fd,
const char *  p,
int  cnt 
) [static]

Definition at line 1622 of file pcp.c.

{
       while (cnt > 0)
       {
              int n=write(fd, p, cnt);

              if (n <= 0)
                     exit(0);

              p += n;
              cnt -= n;
       }
}

Here is the caller graph for this function:

static void dodelete ( const char *  id,
int  flags 
) [static]

Definition at line 1353 of file pcp.c.

{
       struct PCP *pcp=open_calendar();
       struct PCP_delete del;

       memset(&del, 0, sizeof(del));
       del.id=id;

       if (pcp_delete(pcp, &del))
       {
              error(pcp, del.errcode, "pcp_delete");
              exit(1);
       }
       pcp_close(pcp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void doretr ( const char *  eventid) [static]

Definition at line 967 of file pcp.c.

{
       struct PCP *pcp;
       struct PCP_retr r;
       struct xretrinfo xr;
       const char *event_id_array[2];
       struct xretr_time_list *tl;
       struct xretr_participant_list *pl;

       pcp=open_calendar();

       memset(&r, 0, sizeof(r));
       memset(&xr, 0, sizeof(xr));

       r.callback_arg= &xr;
       r.callback_retr_status=doretr_status;
       r.callback_retr_date=doretr_date;
       r.callback_retr_participants=doretr_participants;

       event_id_array[0]=eventid;
       event_id_array[1]=NULL;

       r.event_id_list=event_id_array;

       if (pcp_retr(pcp, &r) == 0)
       {
              r.callback_retr_status=NULL;
              r.callback_retr_date=NULL;
              r.callback_retr_participants=NULL;

              r.callback_begin_func=doretr_begin;
              r.callback_rfc822_func=doretr_save;
              r.callback_end_func=do_show_retr;
              if (pcp_retr(pcp, &r) == 0)
              {
                     pcp_close(pcp);
              }
              else
              {
                     error(pcp, r.errcode, "pcp_retr");
                     pcp_close(pcp);
              }
       }
       else
       {
              error(pcp, r.errcode, "pcp_retr");
              pcp_close(pcp);
       }

       while ((pl=xr.participant_list) != NULL)
       {
              xr.participant_list=pl->next;
              free(pl->participant);
              free(pl);
       }

       while ((tl=xr.time_list) != NULL)
       {
              xr.time_list=tl->next;
              free(tl);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int doretr_begin ( struct PCP_retr r,
void *  vp 
) [static]

Definition at line 1030 of file pcp.c.

{
       struct xretrinfo *xr=(struct xretrinfo *)vp;

       if ((xr->tmpfile=tmpfile()) == NULL)
              return (-1);
       return (0);
}

Here is the caller graph for this function:

static int doretr_date ( struct PCP_retr p,
time_t  from,
time_t  to,
void *  vp 
) [static]

Definition at line 931 of file pcp.c.

{
       struct xretrinfo *xr=(struct xretrinfo *)vp;
       struct xretr_time_list *t=malloc(sizeof(struct xretr_time_list));

       if (!t)
              return (-1);

       t->next=xr->time_list;
       xr->time_list=t;
       t->from=from;
       t->to=to;
       return (0);
}

Here is the caller graph for this function:

static int doretr_participants ( struct PCP_retr p,
const char *  n,
const char *  id,
void *  vp 
) [static]

Definition at line 946 of file pcp.c.

{
       struct xretrinfo *xr=(struct xretrinfo *)vp;
       char *s=strdup(n);
       struct xretr_participant_list *pa;

       if (!s)
              return (-1);

       if ((pa=malloc(sizeof(struct xretr_participant_list))) == NULL)
       {
              free(s);
              return (-1);
       }
       pa->participant=s;
       pa->next=xr->participant_list;
       xr->participant_list=pa;
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int doretr_save ( struct PCP_retr r,
const char *  p,
int  n,
void *  vp 
) [static]

Definition at line 1039 of file pcp.c.

{
       struct xretrinfo *xr=(struct xretrinfo *)vp;

       if (fwrite(p, n, 1, xr->tmpfile) != 1)
              return (-1);
       return (0);
}

Here is the caller graph for this function:

static int doretr_status ( struct PCP_retr p,
int  status,
void *  vp 
) [static]

Definition at line 923 of file pcp.c.

{
       struct xretrinfo *xr=(struct xretrinfo *)vp;

       xr->status=status;
       return (0);
}

Here is the caller graph for this function:

static void douncancel ( const char *  id,
int  flags 
) [static]

Definition at line 1369 of file pcp.c.

{
       struct PCP *pcp=open_calendar();
       struct PCP_uncancel uncancel_info;

       memset(&uncancel_info, 0, sizeof(uncancel_info));
       uncancel_info.uncancel_conflict_callback= &show_conflict;
       uncancel_info.uncancel_conflict_callback_ptr=NULL;

       if (pcp_uncancel(pcp, id, flags, &uncancel_info))
       {
              error(pcp, uncancel_info.errcode, "pcp_uncancel");
              exit(1);
       }
       pcp_close(pcp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dump_rfc822_hdr ( const char *  ptr,
size_t  cnt,
void *  dummy 
) [static]

Definition at line 578 of file pcp.c.

{
       fwrite(ptr, cnt, 1, stdout);
}

Here is the caller graph for this function:

static void error ( struct PCP pcp,
int  n,
const char *  s 
) [static]

Definition at line 84 of file pcp.c.

{
       const char *p;

       p=pcp_strerror(n);

       if (p)
              fprintf(stderr, "%s: %s\n", s, p);
       else
              fprintf(stderr, "%s: %s\n", s, pcp_errmsg(pcp));
}

Here is the call graph for this function:

static const char* event_s ( ) [static]

Definition at line 74 of file pcp.c.

{
       return (gettext("event"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* from_s ( ) [static]

Definition at line 64 of file pcp.c.

{
       return (gettext("from"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int indexcmp ( const void *  a,
const void *  b 
) [static]

Definition at line 561 of file pcp.c.

{
       struct listinfo_index *ap=*(struct listinfo_index * const *)a;
       struct listinfo_index *bp=*(struct listinfo_index * const *)b;

       return ( ap->from < bp->from ? -1:
               ap->from > bp->from ? 1:
               ap->to < bp->to ? -1:
               ap->to > bp->to ? 1:0);
}

Here is the caller graph for this function:

static void init ( const char *  shell) [static]

Definition at line 1388 of file pcp.c.

{
       struct passwd *pw=do_getpw();

       if (chdir(pw->pw_dir))
       {
              perror(pw->pw_dir);
              exit(1);
       }
       unlink(".pcplogin");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void list ( int  argn,
int  argc,
char **  argv,
int  flags 
) [static]

Definition at line 585 of file pcp.c.

{
       struct listinfo listinfo;
       int all_flag=0;
       struct PCP *pcp;
       struct PCP_list_all list_all;

       memset(&listinfo, 0, sizeof(listinfo));
       memset(&list_all, 0, sizeof(list_all));

       while (argn < argc)
       {
              if (strcasecmp(argv[argn], gettext("all")) == 0)
              {
                     all_flag=1;
                     ++argn;
                     continue;
              }

              if (strcasecmp(argv[argn], on_s()) == 0)
              {
                     ++argn;
                     if (listinfo.list_from ||
                         listinfo.list_to ||
                         (listinfo.list_from=
                          listinfo.list_to=
                          parse_datetime(&argn, argc, argv)) == 0)
                            usage();
                     continue;
              }

              if (strcasecmp(argv[argn], from_s()) == 0)
              {
                     ++argn;
                     if (listinfo.list_from != 0 ||
                         (listinfo.list_from=
                          parse_datetime(&argn, argc, argv)) == 0)
                            usage();
                     continue;
              }

              if (strcasecmp(argv[argn], to_s()) == 0)
              {
                     ++argn;
                     if (listinfo.list_to != 0 ||
                         (listinfo.list_to=
                          parse_datetime(&argn, argc, argv)) == 0)
                            usage();
                     continue;
              }

              if (strcasecmp(argv[argn], event_s()) == 0)
              {
                     ++argn;
                     if (argn >= argc || listinfo.list_event_id)
                            usage();
                     listinfo.list_event_id=argv[argn++];
                     continue;
              }
              usage();
       }

       /* If neither start-end, nor "all" is specified, list events
          for today */

       if (!all_flag && listinfo.list_from == 0 &&
           listinfo.list_to == 0 && !listinfo.list_event_id)
       {
              time_t t;
              struct tm *tmptr;

              time(&t);
              tmptr=localtime(&t);

              pcp_parse_ymd(tmptr->tm_year + 1900,
                           tmptr->tm_mon + 1,
                           tmptr->tm_mday,
                           &listinfo.list_from,
                           &listinfo.list_to);
       }

       if ((listinfo.list_from || listinfo.list_to)
           && listinfo.list_event_id)
       usage();

       if (listinfo.list_event_id)
       {
              doretr(listinfo.list_event_id);
              return;
       }

       pcp=open_calendar();

       list_all.callback_func=list_callback_saveindex;
       list_all.callback_arg= &listinfo;
       list_all.list_from=listinfo.list_from;
       list_all.list_to=listinfo.list_to;
       listinfo.i_cnt=0;
       if (pcp_list_all(pcp, &list_all))
       {
              perror("pcp_xlist");
              pcp_close(pcp);
              exit(1);
       }

       /* Show event index */

       if (listinfo.index_list)
       {
              unsigned cnt=0, i, maxl;
              struct listinfo_index *p, **ary;
              const char **event_id_list;
              struct PCP_retr r;

              for (p=listinfo.index_list; p; p=p->next)
                     ++cnt;

              event_id_list=(const char **)
                     malloc(sizeof(const char *)*(cnt+1));
              if (!event_id_list)
              {
                     perror("malloc");
                     exit(1);
              }
              cnt=0;

              for (p=listinfo.index_list; p; p=p->next)
                     event_id_list[cnt++]=p->eventid;
              event_id_list[cnt]=0;
              memset(&r, 0, sizeof(r));
              r.callback_arg=&listinfo;

              r.callback_retr_status=save_retr_status;
              r.callback_arg=&listinfo;
              r.event_id_list=event_id_list;

              if (pcp_retr(pcp, &r))
              {
                     error(pcp, r.errcode, "pcp_retr");
                     pcp_close(pcp);
                     exit(1);
              }

              r.callback_headers_func=save_retr_headers;

              if (pcp_retr(pcp, &r))
              {
                     error(pcp, r.errcode, "pcp_retr");
                     pcp_close(pcp);
                     exit(1);
              }

              free(event_id_list);

              ary=(struct listinfo_index **)
                     malloc(sizeof(struct listinfo_index *)
                            * listinfo.i_cnt);

              if (!ary)
              {
                     perror("malloc");
                     pcp_close(pcp);
                     exit(1);
              }

              cnt=0;
              for (p=listinfo.index_list; p; p=p->next)
                     ary[cnt++]=p;
              qsort(ary, cnt, sizeof(ary[0]), indexcmp);

              maxl=20;

              for (i=0; i<cnt; i++)
              {
                     char fromto[500];

                     if (pcp_fmttimerange(fromto, sizeof(fromto),
                                        ary[i]->from,
                                        ary[i]->to) == 0 &&
                         strlen(fromto) > maxl)
                            maxl=strlen(fromto);
              }

              for (i=0; i<cnt; i++)
              {
                     char fromto[500];

                     if (pcp_fmttimerange(fromto, sizeof(fromto),
                                        ary[i]->from,
                                        ary[i]->to) < 0)
                            strcpy(fromto, "******");
                     printf("%-*s %s%s", (int)maxl, fromto,
                            ary[i]->status & LIST_CANCELLED
                            ? gettext("CANCELLED: "):"",
                            ary[i]->status & LIST_BOOKED
                            ? gettext("(event not yet commited) "):"");

                     if (rfc822_display_hdrvalue("subject",
                                              ary[i]->subject
                                              ? ary[i]->subject:"",
                                              charset,
                                              dump_rfc822_hdr,
                                              NULL, NULL) < 0)
                     {
                            printf("%s", 
                                   ary[i]->subject
                                   ? ary[i]->subject:"");
                     }
                     printf("\n");

                     if (flags & FLAG_LIST_EVENT_ID)
                            printf("%-*s(%s)\n", (int)maxl, "",
                                   ary[i]->eventid);
              }
              free(ary);
              listinfo.cnt=cnt;
       }

       printf(gettext("%d events found.\n"), listinfo.cnt);

       while (listinfo.index_list)
       {
              struct listinfo_index *p=listinfo.index_list;

              listinfo.index_list=p->next;
              free(p->eventid);
              if (p->subject)
                     free(p->subject);
              free(p);
       }
       pcp_close(pcp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int list_callback_saveindex ( struct PCP_list_all xl,
void *  vp 
) [static]

Definition at line 818 of file pcp.c.

{
       struct listinfo *li=(struct listinfo *)vp;
       struct listinfo_index *i;

       li->cnt++;

       if ((i=(struct listinfo_index *)
            malloc(sizeof(struct listinfo_index))) == NULL)
       {
              perror("malloc");
              exit(1);
       }
       memset(i, 0, sizeof(*i));

       if ((i->eventid=strdup(xl->event_id)) == NULL)
       {
              free(i);
              perror("malloc");
              exit(1);
       }

       i->next=li->index_list;
       li->index_list=i;
       ++li->i_cnt;
       i->from=xl->event_from;
       i->to=xl->event_to;
       i->subject=NULL;
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int list_msg_mime ( struct rfc2045 rfc,
FILE *  fp 
) [static]

Definition at line 1204 of file pcp.c.

{
       int (*handler)(struct rfc2045 *, FILE *)=
              mime_handler(rfc);
       const char      *content_type, *dummy;


       char *disposition_name;
       char *disposition_filename;
       char *content_name;

       const char *disposition_filename_s;

       off_t start_pos, end_pos, start_body;
       off_t dummy2;
       char buffer[NUMBUFSIZE+10];

       if (handler)
              return ( (*handler)(rfc, fp));

        rfc2045_mimeinfo(rfc, &content_type, &dummy, &dummy);

       if (rfc2231_udecodeDisposition(rfc, "name", NULL, &disposition_name)<0)
              disposition_name=NULL;

       if (rfc2231_udecodeDisposition(rfc, "filename", NULL,
                                   &disposition_filename) < 0)
              disposition_filename=NULL;

       if (rfc2231_udecodeType(rfc, "name", NULL, &content_name) < 0)
              content_name=NULL;

        rfc2045_mimepos(rfc, &start_pos, &end_pos, &start_body,
                        &dummy2, &dummy2);

       disposition_filename_s=disposition_filename;

       if (!disposition_filename_s || !*disposition_filename_s)
              disposition_filename_s=disposition_name;
       if (!disposition_filename_s || !*disposition_filename_s)
              disposition_filename_s=content_name;

       printf(gettext("Attachment: %s (%s)\n"), content_type,
              libmail_str_sizekb(end_pos - start_body, buffer));
       if (disposition_filename_s && *disposition_filename_s)
              printf("    %s\n", disposition_filename_s);
       printf("\n");

       if (content_name)           free(content_name);
       if (disposition_name)              free(disposition_name);
       if (disposition_filename)   free(disposition_filename);

       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int list_msg_mime_multipart ( struct rfc2045 rfc,
FILE *  fp 
) [static]

Definition at line 1259 of file pcp.c.

{
       struct rfc2045 *q;
       int first=1;
       int rc;

       for (q=rfc->firstpart; q; q=q->next)
       {
              if (q->isdummy) continue;

              if (!first)
                     printf("\n    ------------------------------\n\n");
              first=0;

              rc=list_msg_mime(q, fp);
              if (rc)
                     return (rc);
       }
       return (0);
}

Here is the call graph for this function:

static int list_msg_mime_multipart_alternative ( struct rfc2045 rfc,
FILE *  fp 
) [static]

Definition at line 1280 of file pcp.c.

{
       struct rfc2045 *q, *first=NULL, *last=NULL;

       for (q=rfc->firstpart; q; q=q->next)
       {
              if (q->isdummy) continue;
              if (!first)
                     first=q;
              if ( mime_handler(q) != NULL)
                     last=q;
       }

       return (last ? list_msg_mime(last, fp):
              first ? list_msg_mime(first, fp):0);
}

Here is the call graph for this function:

static int list_msg_rfc822 ( struct rfc2045 rfc,
FILE *  fp 
) [static]

Definition at line 1135 of file pcp.c.

{
       off_t   start_pos, end_pos, start_body;
       off_t  dummy, pos;
       struct rfc822hdr h;

        rfc2045_mimepos(rfc, &start_pos, &end_pos, &start_body,
                     &dummy, &dummy);
        if (fseek(fp, start_pos, SEEK_SET) < 0)
              return (-1);

       pos=start_pos;
       rfc822hdr_init(&h, 8192);

       while (rfc822hdr_read(&h, fp, &pos, start_body) == 0)
       {
              printf("%s: ", h.header);

              if (rfc822_display_hdrvalue(h.header, h.value, charset,
                                       dump_rfc822_hdr, NULL, NULL) < 0)
              {
                     printf("%s", h.value);
              }

              printf("\n");
       }
       rfc822hdr_free(&h);
       printf("\n");
       return (list_msg_mime(rfc, fp));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int list_msg_rfc822_part ( struct rfc2045 rfc,
FILE *  fp 
) [static]

Definition at line 1166 of file pcp.c.

{
       struct rfc2045 *q;

       for (q=rfc->firstpart; q; q=q->next)
       {
              if (q->isdummy) continue;
              return (list_msg_rfc822(q, fp));
       }
       return (0);
}

Here is the call graph for this function:

static int list_msg_textplain ( struct rfc2045 rfc,
FILE *  fp 
) [static]

Definition at line 1308 of file pcp.c.

{
       const char *mime_charset, *dummy;
       int rc;
       struct rfc2045src *src;

        rfc2045_mimeinfo(rfc, &dummy, &dummy, &mime_charset);

        if (strcasecmp(mime_charset, charset))
        {
              printf(gettext("    (The following text was converted from %s)\n\n"),
                     mime_charset);
       }

       src=rfc2045src_init_fd(fileno(fp));

       if (src == NULL)
              return (-1);

       rc=rfc2045_decodetextmimesection(src,
                                    rfc,
                                    charset,
                                    NULL,
                                    textplain_output, NULL);

       printf("\n");
       rfc2045src_deinit(src);
       return (rc);
}

Here is the call graph for this function:

static void listacls ( ) [static]

Definition at line 1513 of file pcp.c.

{
       struct PCP *pcp=open_calendar();

       if (pcp_has_acl(pcp))
       {
              if (pcp_list_acl(pcp, do_list_acl, NULL))
              {
                     error(pcp, 0, "pcp_list_acl");
                     exit(1);
              }
       }
       else
       {
              fprintf(stderr, gettext("ERROR: ACLs not supported.\n"));
       }
       pcp_close(pcp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void login ( const char *  userid) [static]

Definition at line 1402 of file pcp.c.

{
       char *errmsg;
       char password[1024];
       struct PCP *pcp;
       char *p;

#if HAVE_TCGETATTR
       struct termios tios;
       int tios_rc=tcgetattr(0, &tios);

       if (tios_rc >= 0)
       {
              tios.c_lflag &= ~ECHO;
              tcsetattr(0, TCSANOW, &tios);
       }
#endif

       printf(gettext("Password: "));

       if (fgets(password, sizeof(password), stdin) == NULL)
              password[0]=0;

#if HAVE_TCGETATTR
       if (tios_rc >= 0)
       {
              tios.c_lflag |= ECHO;
              tcsetattr(0, TCSANOW, &tios);
              printf("\n");
       }
#endif

       if ((p=strchr(password, '\n')) != 0)
              *p=0;

       pcp=pcp_open_server(userid, password, &errmsg);

       if (pcp)
       {
              struct passwd *pw=do_getpw();
              FILE *fp;
              const char *p=pcp_authtoken(pcp);

              if (!p)
              {
                     fprintf(stderr, gettext("ERROR: Unable to obtain authentication token from the server.\n"));
                     exit(1);
              }

              if (chdir(pw->pw_dir) < 0)
              {
                     perror(pw->pw_dir);
                     exit(1);
              }
              umask(077);
              fp=fopen(".pcplogin", "w");

              if (!fp)
              {
                     perror("$HOME/.pcplogin");
                     exit(1);
              }

              fprintf(fp, "%s\n%s\n", userid, p);
              if (fflush(fp) < 0 || ferror(fp) || fclose(fp))
              {
                     perror("$HOME/.pcplogin");
                     unlink(".pcplogin");
                     exit(1);
              }
              pcp_close(pcp);
              return;
       }

       printf(gettext("ERROR:\n%s\n"), errmsg ? errmsg:strerror(errno));
       if (errmsg)
              free(errmsg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main ( int  argc,
char **  argv 
)

Definition at line 1708 of file pcp.c.

{
       int flags=0;
       int list_flags=0;
       int optchar;
       const char *subject=0;
       int ismime=0;

       setlocale(LC_ALL, "");
       textdomain("pcp");

       charset=unicode_default_chset();

       while ((optchar=getopt(argc, argv, "emcs:C:")) >= 0)
       {
              switch (optchar) {
              case 'c':
                     flags |= PCP_OK_CONFLICT;
                     break;
              case 's':
                     subject=optarg;
                     break;
              case 'C':
                     charset=optarg;
                     break;
              case 'm':
                     ismime=1;
                     break;
              case 'e':
                     list_flags |= FLAG_LIST_EVENT_ID;
                     break;
              default:
                     usage();
              }
       }

       if (optind < argc)
       {
              const char *addstr=gettext("add");
              const char *updatestr=gettext("update");

              if (strcmp(argv[optind], gettext("init")) == 0)
              {
                     ++optind;
                     init(optind < argc ? argv[optind]:NULL);
                     exit(0);
              }
              else if (strcmp(argv[optind], gettext("login")) == 0)
              {
                     ++optind;
                     if (optind < argc)
                     {
                            login(argv[optind]);
                            exit (0);
                     }
              }
              else if (strcmp(argv[optind], gettext("connect")) == 0)
              {
                     int fd;
                     const char *n;

                     ++optind;
                     n=optind < argc ? argv[optind] : PUBDIR "/50PCPDLOCAL";
                     fd=doconnect(n);

                     if (fcntl(fd, F_SETFL, 0) < 0)
                     {
                            perror(argv[optind]);
                            exit (0);
                     }
                     printf("Connected to %s...\n", n);
                     doconnectloop(fd);
                     exit (0);
              }
              else if (strcmp(argv[optind], gettext("sconnect")) == 0)
              {
                     int fd;
                     const char *n;

                     ++optind;
                     n=optind < argc ? argv[optind]
                            : PRIVDIR "/50PCPDLOCAL";
                     fd=doconnect(n);

                     if (fcntl(fd, F_SETFL, 0) < 0)
                     {
                            perror(argv[optind]);
                            exit (0);
                     }
                     printf("Connected to %s...\n", n);
                     doconnectloop(fd);
                     exit (0);
              }
              else if (strcmp(argv[optind], gettext("cancel")) == 0)
              {
                     ++optind;
                     if (optind < argc)
                     {
                            docancel(argv[optind], flags);
                            exit (0);
                     }
              }
              else if (strcmp(argv[optind], gettext("delete")) == 0)
              {
                     ++optind;
                     if (optind < argc)
                     {
                            dodelete(argv[optind], flags);
                            exit (0);
                     }
              }
              else if (strcmp(argv[optind], gettext("uncancel")) == 0)
              {
                     ++optind;
                     if (optind < argc)
                     {
                            douncancel(argv[optind], flags);
                            exit (0);
                     }
              }
              else if (strcmp(argv[optind], addstr) == 0 ||
                      strcmp(argv[optind], updatestr) == 0)
              {
                     struct add_info info;
                     const char *oldeventid=0;

                     ++optind;

                     if (strcmp(argv[optind-1], updatestr) == 0)
                     {
                            if (optind >= argc)
                                   usage();
                            oldeventid=argv[optind++];
                     }

                     memset(&info, 0, sizeof(info));

                     if (ismime)
                            info.add_func=add_read_stdin;
                     else
                     {
                            info.add_func=add_read_subject;
                            info.add_charset=charset;
                            if (subject)
                                   info.add_subject=mimeify(subject,
                                                         charset);
                            else
                            {
                                   char *p;

                                   if (!isatty(0))
                                   {
                                          fprintf(stderr,
                                                 gettext("Error: -s is required\n"));
                                          exit(1);
                                   }

                                   p=read_subject();

                                   info.add_subject=mimeify(p, charset);
                                   free(p);
                            }
                     }
                     add(optind, argc, argv, flags, oldeventid, &info);
                     exit (0);
              }
              else if (strcmp(argv[optind], gettext("list")) == 0)
              {
                     list(optind+1, argc, argv, list_flags);
                     exit (0);
              }
              else if (strcmp(argv[optind], gettext("setacl")) == 0)
              {
                     int flags=0;
                     const char *acl;

                     if (++optind < argc)
                     {
                            acl=argv[optind];

                            while (++optind < argc)
                                   flags |= pcp_acl_num(argv[optind]);

                            setacl(acl, flags);
                     }
                     exit (0);
              }
              else if (strcmp(argv[optind], gettext("listacl")) == 0)
              {
                     listacls();
                     exit(0);
              }
       }

       usage();
       return (0);
}

Here is the call graph for this function:

static char* mimeify ( const char *  subject,
const char *  charset 
) [static]

Definition at line 1695 of file pcp.c.

{
       char *p=rfc2047_encode_str(subject, charset,
                               rfc2047_qp_allow_any);

       if (!p)
       {
              perror("rfc2047_encode_str");
              exit(1);
       }
       return (p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* on_s ( ) [static]

Definition at line 79 of file pcp.c.

{
       return (gettext("on"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct PCP* open_calendar ( ) [read]

Definition at line 144 of file pcp.c.

{
       struct PCP *pcp;
       struct passwd *pw=do_getpw();
       char *p;
       const char *cp;
       FILE *fp;
       char authtoken[1024];

       p=malloc(strlen(pw->pw_dir)+sizeof("/.pcplogin"));
       if (!p)
       {
              perror("malloc");
              exit(1);
       }

       strcat(strcpy(p, pw->pw_dir), "/.pcplogin");

       if ((fp=fopen(p, "r")) != NULL)
       {
              if (fgets(authtoken, sizeof(authtoken)-2, fp) != NULL)
              {
                     char *q=authtoken+strlen(authtoken);

                     if (fgets(q, sizeof(authtoken)- (q-authtoken), fp)
                         != NULL)
                     {
                            char *userid=strtok(authtoken, "\n");
                            const char *cp;

                            if (userid)
                            {
                                   char *password=strtok(NULL, "\n");
                                   char *errmsg;

                                   fclose(fp);

                                   pcp=pcp_reopen_server(userid,
                                                       password,
                                                       &errmsg);

                                   if (!pcp)
                                   {
                                          printf(gettext("LOGIN ERROR:\n%s\n"),
                                                 errmsg ?
                                                 errmsg:strerror(errno));
                                          if (errmsg)
                                                 free(errmsg);
                                          exit(1);
                                   }

                                   cp=pcp_authtoken(pcp);

                                   if (!cp)
                                   {
                                          fprintf(stderr, gettext("ERROR: Unable to obtain authentication token from the server.\n"));
                                          exit(1);
                                   }

                                   umask(077);

                                   if ((fp=fopen(p, "w")) == NULL)
                                   {
                                          perror(p);
                                          exit(1);
                                   }

                                   fprintf(fp, "%s\n%s\n",
                                          userid,
                                          cp);
                                   if (fflush(fp) || ferror(fp)
                                       || fclose(fp))
                                   {
                                          perror(p);
                                          unlink(p);
                                          exit(1);
                                   }
                                   free(p);
                                   return (pcp);
                            }
                     }
              }
              fclose(fp);
              unlink(p);
       }

       if ((cp=getenv("PCPDIR")) != NULL && *cp)
       {
              free(p);
              p=strdup(cp);
              if (!p)
              {
                     perror("strdup");
                     exit(1);
              }
       }
       else
       {
              strcat(strcpy(p, pw->pw_dir), "/.pcp");
       }

       if (mkdir(p, 0700) == 0)
       {
              fprintf(stderr, "pcp: created %s\n", p);
       }

       pcp=pcp_open_dir(p, pw->pw_name);
       free(p);

       if (!pcp)
       {
              perror("pcp_open_dir");
              exit(1);
       }

       if (pcp_cleanup(pcp))
       {
              perror("pcp_cleanup");
              pcp_close(pcp);
              return (NULL);
       }
       return (pcp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PCP_STRERROR time_t parse_datetime ( int *  argn,
int  argc,
char **  argv 
) [static]

Definition at line 52 of file pcp.c.

{
       struct pcp_parse_datetime_info pdi;

       memset(&pdi, 0, sizeof(pdi));

       pdi.today_name=gettext("today");
       pdi.tomorrow_name=gettext("tomorrow");

       return (pcp_parse_datetime(argn, argc, argv, &pdi));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* read_subject ( ) [static]

Definition at line 1671 of file pcp.c.

{
       char buf[BUFSIZ];
       char *p;

       printf("Subject: ");

       if (fgets(buf, sizeof(buf), stdin) == NULL)
              exit(0);

       p=strchr(buf, '\n');
       if (p)
              *p=0;

       p=strdup(buf);

       if (!p)
       {
              perror("malloc");
              exit(1);
       }
       return (p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rfc2045_enomem ( )

Definition at line 44 of file pcp.c.

{
       fprintf(stderr, "Out of memory.\n");
       exit(1);
}

Here is the caller graph for this function:

static int save_retr_headers ( struct PCP_retr ri,
const char *  h,
const char *  v,
void *  vp 
) [static]

Definition at line 862 of file pcp.c.

{
       struct listinfo *l=(struct listinfo *)vp;
       struct listinfo_index *i;
       char *p, *q;

       if (strcasecmp(h, "subject"))
              return (0);

       for (i=l->index_list; i; i=i->next)
              if (strcmp(i->eventid, ri->event_id) == 0)
              {
                     if (!i->subject)
                     {
                            i->subject=strdup(v);
                            if (!i->subject)
                                   return (-1);
                     }

                     for (p=q=i->subject; *p; )
                     {
                            if (*p == '\n')
                            {
                                   while (*p && isspace((int)
                                                      (unsigned char)
                                                      *p))
                                          ++p;
                                   *q++=' ';
                                   continue;
                            }
                            *q++ = *p++;
                     }
                     *q=0;
              }
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int save_retr_status ( struct PCP_retr r,
int  status,
void *  vp 
) [static]

Definition at line 849 of file pcp.c.

{
       struct listinfo *l=(struct listinfo *)vp;
       struct listinfo_index *i;

       for (i=l->index_list; i; i=i->next)
              if (strcmp(i->eventid, r->event_id) == 0)
              {
                     i->status=status;
              }
       return (0);
}

Here is the caller graph for this function:

static int save_time ( time_t  start,
time_t  end,
void *  vp 
) [static]

Definition at line 101 of file pcp.c.

{
       struct event_time_list **ptr=(struct event_time_list **)vp;
       struct event_time_list *etl=
              (struct event_time_list *)
              malloc(sizeof(struct event_time_list));

       if (!etl)
       {
              perror("malloc");
              exit(1);
       }

       for (; *ptr; ptr=&(*ptr)->next)
                            ;
       *ptr=etl;
       etl->next=NULL;

       etl->thetime.start=start;
       etl->thetime.end=end;
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void setacl ( const char *  who,
int  flags 
) [static]

Definition at line 1483 of file pcp.c.

{
       struct PCP *pcp=open_calendar();

       if (pcp_has_acl(pcp))
       {
              if (pcp_acl(pcp, who, flags))
              {
                     error(pcp, 0, "pcp_acl");
                     exit(1);
              }
       }
       else
       {
              fprintf(stderr, gettext("ERROR: ACLs not supported.\n"));
       }
       pcp_close(pcp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int show_conflict ( const char *  event_id,
time_t  from,
time_t  to,
const char *  addr,
void *  dummy 
) [static]

Definition at line 283 of file pcp.c.

{
       char buf[500];

       if (pcp_fmttimerange(buf, sizeof(buf), from, to) < 0)
              buf[0]=0;

       fprintf(stderr, gettext("Conflict: %s\n    (%s)\n"),
              buf, event_id);
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int tcmp ( const void *  a,
const void *  b 
) [static]

Definition at line 1048 of file pcp.c.

{
       struct xretr_time_list *ap=*(struct xretr_time_list **)a;
       struct xretr_time_list *bp=*(struct xretr_time_list **)b;

       return ( ap->from < bp->from ? -1:
               ap->from > bp->from ? 1:
               ap->to < bp->to ? -1:
               ap->to > bp->to ? 1:0);
}

Here is the caller graph for this function:

static int textplain_output ( const char *  ptr,
size_t  cnt,
void *  voidptr 
) [static]

Definition at line 1297 of file pcp.c.

{
       while (cnt)
       {
              putchar(*ptr);
              ++ptr;
              --cnt;
       }
       return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* to_s ( ) [static]

Definition at line 69 of file pcp.c.

{
       return (gettext("to"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void usage ( ) [static]

Definition at line 1636 of file pcp.c.

{
       const char *charset=unicode_default_chset();

       fprintf(stderr,
              gettext("Usage: pcp [options] [command]\n"
                     "\n"
                     "Options:\n"
                     "   -c           - add/uncancel event that conflicts with an existing event\n"
                     "   -s subject   - specify event subject\n"
                     "   -C charset   - specify your local charset (default %s)\n"
                     "   -m           - standard input is already a MIME-formatted message\n"
                     "   -e           - list event ids\n"
                     "\n"), charset);

       fprintf(stderr, "%s",
              gettext(
                     "Commands:\n"
                     "   init\n"
                     "   login USERID\n"
                     "   logout\n"
                     "   add from FROM to TO [ from FROM to TO...]\n"
                     "   update ID from FROM to TO [ from FROM to TO...]\n"
                     "   list [all] [from FROM] [to TO] [event ID]\n"
                     "   cancel ID\n"
                     "   uncancel ID\n"
                     "   delete ID\n"
                     "   connect [/pathname]\n"
                     "   sconnect [/pathname]\n"
                     "   setacl [MODIFY|CONFLICT|LIST|RETR|NONE]*\n"
                     "   listacl\n"
                     ));
       exit(1);
}

Here is the call graph for this function:


Variable Documentation

const char* charset = RFC2045CHARSET [static]

Definition at line 42 of file pcp.c.

int(*)(struct rfc2045 *, FILE *) mime_handler(struct rfc2045 *rfc) [static]

Definition at line 1183 of file pcp.c.

{
       const char      *content_type, *dummy;

        rfc2045_mimeinfo(rfc, &content_type, &dummy, &dummy);
        if (strcmp(content_type, "multipart/alternative") == 0)
              return ( &list_msg_mime_multipart_alternative);
        if (strncmp(content_type, "multipart/", 10) == 0)
              return ( &list_msg_mime_multipart);

        if (strcmp(content_type, "message/rfc822") == 0)
              return ( &list_msg_rfc822_part );

        if (strcmp(content_type, "text/plain") == 0
           || strcmp(content_type, "text/rfc822-headers") == 0
           || strcmp(content_type, "message/delivery-status") == 0)
              return ( &list_msg_textplain);
       return (NULL);
}