external/ibm-public/postfix/dist/src/util/attr_print_plain.c

   1 /*      $NetBSD$        */
   2
   3 /*++
   4 /* NAME
   5 /*      attr_print_plain 3
   6 /* SUMMARY
   7 /*      send attributes over byte stream
   8 /* SYNOPSIS
   9 /*      #include <attr.h>
  10 /*
  11 /*      int     attr_print_plain(fp, flags, type, name, ..., ATTR_TYPE_END)
  12 /*      VSTREAM fp;
  13 /*      int     flags;
  14 /*      int     type;
  15 /*      char    *name;
  16 /*
  17 /*      int     attr_vprint_plain(fp, flags, ap)
  18 /*      VSTREAM fp;
  19 /*      int     flags;
  20 /*      va_list ap;
  21 /* DESCRIPTION
  22 /*      attr_print_plain() takes zero or more (name, value) simple attributes
  23 /*      and converts its input to a byte stream that can be recovered with
  24 /*      attr_scan_plain(). The stream is not flushed.
  25 /*
  26 /*      attr_vprint_plain() provides an alternate interface that is convenient
  27 /*      for calling from within variadic functions.
  28 /*
  29 /*      Attributes are sent in the requested order as specified with the
  30 /*      attr_print_plain() argument list. This routine satisfies the formatting
  31 /*      rules as outlined in attr_scan_plain(3).
  32 /*
  33 /*      Arguments:
  34 /* .IP fp
  35 /*      Stream to write the result to.
  36 /* .IP flags
  37 /*      The bit-wise OR of zero or more of the following.
  38 /* .RS
  39 /* .IP ATTR_FLAG_MORE
  40 /*      After sending the requested attributes, leave the output stream in
  41 /*      a state that is usable for more attribute sending operations on
  42 /*      the same output attribute list.
  43 /*      By default, attr_print_plain() automatically appends an attribute list
  44 /*      terminator when it has sent the last requested attribute.
  45 /* .RE
  46 /* .IP type
  47 /*      The type determines the arguments that follow.
  48 /* .RS
  49 /* .IP "ATTR_TYPE_INT (char *, int)"
  50 /*      This argument is followed by an attribute name and an integer.
  51 /* .IP "ATTR_TYPE_LONG (char *, long)"
  52 /*      This argument is followed by an attribute name and a long integer.
  53 /* .IP "ATTR_TYPE_STR (char *, char *)"
  54 /*      This argument is followed by an attribute name and a null-terminated
  55 /*      string.
  56 /* .IP "ATTR_TYPE_DATA (char *, ssize_t, char *)"
  57 /*      This argument is followed by an attribute name, an attribute value
  58 /*      length, and a pointer to attribute value.
  59 /* .IP "ATTR_TYPE_FUNC (ATTR_PRINT_SLAVE_FN, void *)"
  60 /*      This argument is followed by a function pointer and generic data
  61 /*      pointer. The caller-specified function returns whatever the
  62 /*      specified attribute printing function returns.
  63 /* .IP "ATTR_TYPE_HASH (HTABLE *)"
  64 /* .IP "ATTR_TYPE_NAMEVAL (NVTABLE *)"
  65 /*      The content of the table is sent as a sequence of string-valued
  66 /*      attributes with names equal to the table lookup keys.
  67 /* .IP ATTR_TYPE_END
  68 /*      This terminates the attribute list.
  69 /* .RE
  70 /* DIAGNOSTICS
  71 /*      The result value is 0 in case of success, VSTREAM_EOF in case
  72 /*      of trouble.
  73 /*
  74 /*      Panic: interface violation. All system call errors are fatal.
  75 /* SEE ALSO
  76 /*      attr_scan_plain(3) recover attributes from byte stream
  77 /* LICENSE
  78 /* .ad
  79 /* .fi
  80 /*      The Secure Mailer license must be distributed with this software.
  81 /* AUTHOR(S)
  82 /*      Wietse Venema
  83 /*      IBM T.J. Watson Research
  84 /*      P.O. Box 704
  85 /*      Yorktown Heights, NY 10598, USA
  86 /*--*/
  87
  88 /* System library. */
  89
  90 #include <sys_defs.h>
  91 #include <stdarg.h>
  92 #include <string.h>
  93
  94 /* Utility library. */
  95
  96 #include <msg.h>
  97 #include <mymalloc.h>
  98 #include <vstream.h>
  99 #include <htable.h>
 100 #include <base64_code.h>
 101 #include <vstring.h>
 102 #include <attr.h>
 103
 104 #define STR(x)  vstring_str(x)
 105 #define LEN(x)  VSTRING_LEN(x)
 106
 107 /* attr_vprint_plain - send attribute list to stream */
 108
 109 int     attr_vprint_plain(VSTREAM *fp, int flags, va_list ap)
 110 {
 111     const char *myname = "attr_print_plain";
 112     int     attr_type;
 113     char   *attr_name;
 114     unsigned int_val;
 115     unsigned long long_val;
 116     char   *str_val;
 117     HTABLE_INFO **ht_info_list;
 118     HTABLE_INFO **ht;
 119     static VSTRING *base64_buf;
 120     ssize_t len_val;
 121     ATTR_PRINT_SLAVE_FN print_fn;
 122     void   *print_arg;
 123
 124     /*
 125      * Sanity check.
 126      */
 127     if (flags & ~ATTR_FLAG_ALL)
 128         msg_panic("%s: bad flags: 0x%x", myname, flags);
 129
 130     /*
 131      * Iterate over all (type, name, value) triples, and produce output on
 132      * the fly.
 133      */
 134     while ((attr_type = va_arg(ap, int)) != ATTR_TYPE_END) {
 135         switch (attr_type) {
 136         case ATTR_TYPE_INT:
 137             attr_name = va_arg(ap, char *);
 138             int_val = va_arg(ap, int);
 139             vstream_fprintf(fp, "%s=%u\n", attr_name, (unsigned) int_val);
 140             if (msg_verbose)
 141                 msg_info("send attr %s = %u", attr_name, (unsigned) int_val);
 142             break;
 143         case ATTR_TYPE_LONG:
 144             attr_name = va_arg(ap, char *);
 145             long_val = va_arg(ap, long);
 146             vstream_fprintf(fp, "%s=%lu\n", attr_name, long_val);
 147             if (msg_verbose)
 148                 msg_info("send attr %s = %lu", attr_name, long_val);
 149             break;
 150         case ATTR_TYPE_STR:
 151             attr_name = va_arg(ap, char *);
 152             str_val = va_arg(ap, char *);
 153             vstream_fprintf(fp, "%s=%s\n", attr_name, str_val);
 154             if (msg_verbose)
 155                 msg_info("send attr %s = %s", attr_name, str_val);
 156             break;
 157         case ATTR_TYPE_DATA:
 158             attr_name = va_arg(ap, char *);
 159             len_val = va_arg(ap, ssize_t);
 160             str_val = va_arg(ap, char *);
 161             if (base64_buf == 0)
 162                 base64_buf = vstring_alloc(10);
 163             base64_encode(base64_buf, str_val, len_val);
 164             vstream_fprintf(fp, "%s=%s\n", attr_name, STR(base64_buf));
 165             if (msg_verbose)
 166                 msg_info("send attr %s = [data %ld bytes]",
 167                          attr_name, (long) len_val);
 168             break;
 169         case ATTR_TYPE_FUNC:
 170             print_fn = va_arg(ap, ATTR_PRINT_SLAVE_FN);
 171             print_arg = va_arg(ap, void *);
 172             print_fn(attr_print_plain, fp, flags | ATTR_FLAG_MORE, print_arg);
 173             break;
 174         case ATTR_TYPE_HASH:
 175             ht_info_list = htable_list(va_arg(ap, HTABLE *));
 176             for (ht = ht_info_list; *ht; ht++) {
 177                 vstream_fprintf(fp, "%s=%s\n", ht[0]->key, ht[0]->value);
 178                 if (msg_verbose)
 179                     msg_info("send attr name %s value %s",
 180                              ht[0]->key, ht[0]->value);
 181             }
 182             myfree((char *) ht_info_list);
 183             break;
 184         default:
 185             msg_panic("%s: unknown type code: %d", myname, attr_type);
 186         }
 187     }
 188     if ((flags & ATTR_FLAG_MORE) == 0)
 189         VSTREAM_PUTC('\n', fp);
 190     return (vstream_ferror(fp));
 191 }
 192
 193 int     attr_print_plain(VSTREAM *fp, int flags,...)
 194 {
 195     va_list ap;
 196     int     ret;
 197
 198     va_start(ap, flags);
 199     ret = attr_vprint_plain(fp, flags, ap);
 200     va_end(ap);
 201     return (ret);
 202 }
 203
 204 #ifdef TEST
 205
 206  /*
 207   * Proof of concept test program.  Mirror image of the attr_scan_plain test
 208   * program.
 209   */
 210 #include <msg_vstream.h>
 211
 212 int     main(int unused_argc, char **argv)
 213 {
 214     HTABLE *table = htable_create(1);
 215
 216     msg_vstream_init(argv[0], VSTREAM_ERR);
 217     msg_verbose = 1;
 218     htable_enter(table, "foo-name", mystrdup("foo-value"));
 219     htable_enter(table, "bar-name", mystrdup("bar-value"));
 220     attr_print_plain(VSTREAM_OUT, ATTR_FLAG_NONE,
 221                      ATTR_TYPE_INT, ATTR_NAME_INT, 4711,
 222                      ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234,
 223                      ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee",
 224                ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
 225                      ATTR_TYPE_HASH, table,
 226                      ATTR_TYPE_END);
 227     attr_print_plain(VSTREAM_OUT, ATTR_FLAG_NONE,
 228                      ATTR_TYPE_INT, ATTR_NAME_INT, 4711,
 229                      ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234,
 230                      ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee",
 231                ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
 232                      ATTR_TYPE_END);
 233     if (vstream_fflush(VSTREAM_OUT) != 0)
 234         msg_fatal("write error: %m");
 235
 236     htable_free(table, myfree);
 237     return (0);
 238 }
 239
 240 #endif