addons/Syslog/source/IoSyslog.c

   1 /*#io
   2 Syslog ioDoc(
   3 docCopyright("Jeremy Tregunna", 2005)
   4  docLicense("BSD revised")
   5  docDescription("""Provides access to a Unix system's system logger.
   6  <pre>
   7  logger = Syslog clone do(
   8                                          identity("SyslogTest")
   9                                          facility(facilityMap at("LOG_USER"))
  10                                          options(List append(optionsMap at("LOG_PID"), optionsMap at("LOG_CONS")))
  11                                          priority(priorityMap at("LOG_INFO"))
  12                                          open(facility, options)
  13                                          mask(List append(maskMap at("LOG_PRIMASK")))
  14                                          log(priority, "*** Merely a test ***")
  15                                          close
  16                                          )
  17  </pre>
  18
  19  <p>
  20  Note: This is partially tested. Please let me know of any problems you happen to stumble across, or if it could be better. --Jeremy Tregunna
  21  <p>""")
  22                    docCategory("Server")
  23 */
  24
  25 #include "IoSyslog.h"
  26 #include "IoState.h"
  27 #include "IoList.h"
  28 #include <syslog.h>
  29
  30 #if defined(unix) || defined(__APPLE__)
  31 #include <sys/utsname.h>
  32 #endif
  33
  34 #define DATA(self) ((IoSyslogData *)IoObject_dataPointer(self))
  35
  36 IoTag *IoSyslog_newTag(void *state)
  37 {
  38         IoTag *tag = IoTag_newWithName_("Syslog");
  39         IoTag_state_(tag, state);
  40         IoTag_markFunc_(tag, (IoTagMarkFunc *)IoSyslog_mark);
  41         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoSyslog_free);
  42         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoSyslog_rawClone);
  43         return tag;
  44 }
  45
  46 void IoSyslog_mark(IoSyslog *self)
  47 {
  48         IoObject_shouldMark(DATA(self)->priority);
  49         IoObject_shouldMark(DATA(self)->facility);
  50         IoObject_shouldMark(DATA(self)->ident);
  51         IoObject_shouldMark(DATA(self)->optionsMap);
  52         IoObject_shouldMark(DATA(self)->facilityMap);
  53         IoObject_shouldMark(DATA(self)->priorityMap);
  54         IoObject_shouldMark(DATA(self)->maskMap);
  55 }
  56
  57 IoSyslog *IoSyslog_proto(void *state)
  58 {
  59         IoSyslog *self = IoObject_new(state);
  60
  61         IoObject_tag_(self, IoSyslog_newTag(state));
  62         IoObject_setDataPointer_(self, calloc(1, sizeof(IoSyslogData)));
  63
  64         DATA(self)->syslog_opened = 0;
  65         DATA(self)->priority = IONUMBER(LOG_INFO);
  66         DATA(self)->facility = IONUMBER(LOG_LOCAL0);
  67         DATA(self)->syslog_mask = 0;
  68         DATA(self)->ident = IOSYMBOL("");
  69         DATA(self)->optionsMap = IoMap_new(IOSTATE);
  70         DATA(self)->facilityMap = IoMap_new(IOSTATE);
  71         DATA(self)->priorityMap = IoMap_new(IOSTATE);
  72         DATA(self)->maskMap = IoMap_new(IOSTATE);
  73
  74         IoState_registerProtoWithFunc_(state, self, IoSyslog_proto);
  75
  76         {
  77                 IoMethodTable methodTable[] = {
  78                 {"open", IoSyslog_open},
  79                 {"reopen", IoSyslog_reopen},
  80                 {"isOpen", IoSyslog_isOpen},
  81                 {"close", IoSyslog_close},
  82                 {"identity", IoSyslog_identity},
  83                 {"options", IoSyslog_options},
  84                 {"optionsMap", IoSyslog_optionsMap},
  85                 {"facility", IoSyslog_facility},
  86                 {"facilityMap", IoSyslog_facilityMap},
  87                 {"priority", IoSyslog_priority},
  88                 {"priorityMap", IoSyslog_priorityMap},
  89                 {"mask", IoSyslog_mask},
  90                 {"maskMap", IoSyslog_maskMap},
  91                 {"log", IoSyslog_log},
  92                 {NULL, NULL},
  93                 };
  94                 IoObject_addMethodTable_(self, methodTable);
  95         }
  96
  97         return self;
  98 }
  99
 100 IoSyslog *IoSyslog_rawClone(IoSyslog *proto)
 101 {
 102         IoObject *self = IoObject_rawClonePrimitive(proto);
 103         IoObject_setDataPointer_(self, cpalloc(IoObject_dataPointer(proto), sizeof(IoSyslogData)));
 104         return self;
 105 }
 106
 107 IoSyslog *IoSyslog_new(void *state)
 108 {
 109         IoSyslog *proto = IoState_protoWithInitFunction_(state, IoSyslog_proto);
 110         return IOCLONE(proto);
 111 }
 112
 113 void IoSyslog_free(IoSyslog *self)
 114 {
 115         free(IoObject_dataPointer(self));
 116 }
 117
 118 /* ----------------------------------------------------------- */
 119
 120 void syslog_write(int pri, char *msg)
 121 {
 122         syslog(pri, "%s", msg);
 123 }
 124
 125 IoObject *IoSyslog_open(IoSyslog *self, IoObject *locals, IoMessage *m)
 126 {
 127         /*#io
 128          docSlot("open(aPriority, someOptions, optionalIdentity)", """Opens the syslog for writing. optionaIdentity need not be entered and will default to the name of the distribution of Io you are running (i.e., "IoVM", "IoServer", "IoDesktop" or if you have embedded Io into your application and set Lobby distribution = "foo", it will be set to "foo".""")
 129          */
 130         int syslog_facility, syslog_options;
 131         //int i, max;
 132         char *syslog_ident;
 133
 134         if (DATA(self)->syslog_opened)
 135         {
 136                 IoState_error_(IOSTATE, m, "System log is already open");
 137                 return IONIL(self);
 138         }
 139
 140         {
 141                 DATA(self)->facility = IOREF(IoMessage_locals_numberArgAt_(m, locals, 0));
 142                 if (ISNIL(DATA(self)->facility))
 143                 {
 144                         syslog_facility = LOG_USER;
 145                 }
 146                 else
 147                 {
 148                         syslog_facility = IoObject_dataUint32(DATA(self)->facility);
 149                 }
 150
 151                 DATA(self)->options = IOREF(IoMessage_locals_listArgAt_(m, locals, 1));
 152                 syslog_options = 0;
 153                 if (ISNIL(DATA(self)->options))
 154                 {
 155                         syslog_options = LOG_PID | LOG_CONS;
 156                 }
 157                 else
 158                 {
 159                         List *list = IoList_rawList(DATA(self)->options);
 160
 161                         LIST_FOREACH(list, i, v,
 162                                 syslog_options |= (int)CNUMBER(v);
 163                         );
 164                 }
 165
 166                 syslog_ident = (char *)IOSYMBOL_BYTES(DATA(self)->ident);
 167                 if ((strlen(syslog_ident) == 0) || ISNIL(DATA(self)->ident))
 168                 {
 169                         char *s = CSTRING(IoState_doCString_(IOSTATE, "Lobby distribution"));
 170                         strncpy(syslog_ident, s, strlen(s));
 171                 }
 172
 173                 openlog(syslog_ident, syslog_options, syslog_facility);
 174                 DATA(self)->syslog_opened = 1;
 175                 DATA(self)->syslog_mask = setlogmask(0);
 176                 setlogmask(DATA(self)->syslog_mask);
 177         }
 178
 179         return self;
 180 }
 181
 182 IoObject *IoSyslog_reopen(IoSyslog *self, IoObject *locals, IoMessage *m)
 183 {
 184         /*#io
 185          docSlot("reopen(aFacility, someOptions, optionalIdentity) ", "Reopens an already open log session. This is useful if you wish to change the facility you are logging to, the options you are logging with, or the identity of the session. Takes the same options as the open slot.")
 186          */
 187         /* If the log is already opened, close it, if not, no big deal. */
 188         if (DATA(self)->syslog_opened)
 189         {
 190                 closelog();
 191                 DATA(self)->syslog_opened = 0;
 192         }
 193         IoSyslog_open(self, locals, m);
 194         return self;
 195 }
 196
 197 IoObject *IoSyslog_isOpen(IoSyslog *self, IoObject *locals, IoMessage *m)
 198 {
 199         /*#io
 200          docSlot("isOpen", "Returns self if the log is opened for writing. Otherwise, returns Nil.")
 201          */
 202         return IOBOOL(self, DATA(self)->syslog_opened);
 203 }
 204
 205 IoObject *IoSyslog_close(IoSyslog *self, IoObject *locals, IoMessage *m)
 206 {
 207         /*#io
 208          docSlot("close", "Closes a log that has previously been opened for writing.")
 209          */
 210         if (!DATA(self)->syslog_opened)
 211         {
 212                 IoState_error_(IOSTATE, m, "Log is not open");
 213                 return IONIL(self);
 214         }
 215
 216         closelog();
 217         DATA(self)->syslog_opened = 0;
 218
 219         return self;
 220 }
 221
 222 IoObject *IoSyslog_identity(IoSyslog *self, IoObject *locals, IoMessage *m)
 223 {
 224         /*#io
 225          docSlot("identity(optionalIdentity)", "If optionalIdentity is specified, provides an identity for all of the messages you will be sending to the syslog daemon. Returns the identity.")
 226          */
 227         if (IoMessage_argCount(m) >= 1)
 228         {
 229                 DATA(self)->ident = IOREF(IoMessage_locals_symbolArgAt_(m, locals, 0));
 230         }
 231         return DATA(self)->ident;
 232 }
 233
 234 IoObject *IoSyslog_options(IoSyslog *self, IoObject *locals, IoMessage *m)
 235 {
 236         /*#io
 237          docSlot("options(optionalOptions)", "If optionalOptions is specified, it should represent a list of the logging options you can find in the optionsMap slot. All the values in the supplied aList will be OR'd together when you call the open or reopen slots. Returns the list of options if optionalFacility is omitted.")
 238          */
 239         if (IoMessage_argCount(m) >= 1)
 240         {
 241                 DATA(self)->options = IOREF(IoMessage_locals_listArgAt_(m, locals, 0));
 242         }
 243         return DATA(self)->options;
 244 }
 245
 246 IoObject *IoSyslog_optionsMap(IoSyslog *self, IoObject *locals, IoMessage *m)
 247 {
 248         /*#io
 249          docSlot("optionsMap", "A map containing key/value pairs holding all available options. These include:
 250          <li>LOG_PID</li>
 251          <li>LOG_CONS</li>
 252          <li>LOG_ODELAY</li>
 253          <li>LOG_NDELAY</li>
 254          <li>LOG_NOWAIT</li>
 255          <li>LOG_PERROR</li>")
 256          */
 257         PHash *map = IoObject_dataPointer(DATA(self)->optionsMap);
 258
 259         PHash_at_put_(map, IOSYMBOL("LOG_PID"), IONUMBER(1));
 260         PHash_at_put_(map, IOSYMBOL("LOG_CONS"), IONUMBER(2));
 261         PHash_at_put_(map, IOSYMBOL("LOG_ODELAY"), IONUMBER(4));
 262         PHash_at_put_(map, IOSYMBOL("LOG_NDELAY"), IONUMBER(8));
 263         PHash_at_put_(map, IOSYMBOL("LOG_NOWAIT"), IONUMBER(16));
 264         PHash_at_put_(map, IOSYMBOL("LOG_PERROR"), IONUMBER(32));
 265
 266         return DATA(self)->optionsMap;
 267 }
 268
 269 IoObject *IoSyslog_facility(IoSyslog *self, IoObject *locals, IoMessage *m)
 270 {
 271         /*#io
 272          docSlot("facility(optionalFacility)", "Specifies the logging facility, which can be one of any of the values found in the facilityMap map. If optionalFacility is omitted, returns the currently set facility.")
 273          */
 274         if (IoMessage_argCount(m) >= 1)
 275         {
 276                 DATA(self)->facility = IOREF(IoMessage_locals_numberArgAt_(m, locals, 0));
 277         }
 278         return DATA(self)->facility;
 279 }
 280
 281 IoObject *IoSyslog_facilityMap(IoSyslog *self, IoObject *locals, IoMessage *m)
 282 {
 283         /*#io
 284          docSlot("facilityMap", "Contains the following keys, which represent numbers that can be used when opening a log:
 285          <li>LOG_KERN</li>
 286          <li>LOG_USER</li>
 287          <li>LOG_MAIL</li>
 288          <li>LOG_DAEMON</li>
 289          <li>LOG_AUTH</li>
 290          <li>LOG_SYSLOG</li>
 291          <li>LOG_LPR</li>
 292          <li>LOG_NEWS</li>
 293          <li>LOG_UUCP</li>
 294          <li>LOG_CRON</li>
 295          <li>LOG_AUTHPRIV</li>
 296          <li>LOG_FTP</li>
 297          <li>LOG_RESERVED0</li>
 298          <li>LOG_RESERVED1</li>
 299          <li>LOG_RESERVED2</li>
 300          <li>LOG_RESERVED3</li>
 301          <li>LOG_LOCAL0</li>
 302          <li>LOG_LOCAL1</li>
 303          <li>LOG_LOCAL2</li>
 304          <li>LOG_LOCAL3</li>
 305          <li>LOG_LOCAL4</li>
 306          <li>LOG_LOCAL5</li>
 307          <li>LOG_LOCAL6</li>
 308          <li>LOG_LOCAL7</li>")
 309          */
 310         PHash *map = IoObject_dataPointer(DATA(self)->facilityMap);
 311
 312         PHash_at_put_(map, IOSYMBOL("LOG_KERN"), IONUMBER(0));
 313         PHash_at_put_(map, IOSYMBOL("LOG_USER"), IONUMBER(8));
 314         PHash_at_put_(map, IOSYMBOL("LOG_MAIL"), IONUMBER(16));
 315         PHash_at_put_(map, IOSYMBOL("LOG_DAEMON"), IONUMBER(24));
 316         PHash_at_put_(map, IOSYMBOL("LOG_AUTH"), IONUMBER(32));
 317         PHash_at_put_(map, IOSYMBOL("LOG_SYSLOG"), IONUMBER(40));
 318         PHash_at_put_(map, IOSYMBOL("LOG_LPR"), IONUMBER(48));
 319         PHash_at_put_(map, IOSYMBOL("LOG_NEWS"), IONUMBER(56));
 320         PHash_at_put_(map, IOSYMBOL("LOG_UUCP"), IONUMBER(64));
 321         PHash_at_put_(map, IOSYMBOL("LOG_CRON"), IONUMBER(72));
 322         PHash_at_put_(map, IOSYMBOL("LOG_AUTHPRIV"), IONUMBER(80));
 323         PHash_at_put_(map, IOSYMBOL("LOG_FTP"), IONUMBER(88));
 324         PHash_at_put_(map, IOSYMBOL("LOG_RESERVED0"), IONUMBER(96));
 325         PHash_at_put_(map, IOSYMBOL("LOG_RESERVED1"), IONUMBER(104));
 326         PHash_at_put_(map, IOSYMBOL("LOG_RESERVED2"), IONUMBER(112));
 327         PHash_at_put_(map, IOSYMBOL("LOG_RESERVED3"), IONUMBER(120));
 328         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL0"), IONUMBER(128));
 329         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL1"), IONUMBER(136));
 330         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL2"), IONUMBER(144));
 331         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL3"), IONUMBER(152));
 332         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL4"), IONUMBER(160));
 333         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL5"), IONUMBER(168));
 334         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL6"), IONUMBER(176));
 335         PHash_at_put_(map, IOSYMBOL("LOG_LOCAL7"), IONUMBER(184));
 336
 337         return DATA(self)->facilityMap;
 338 }
 339
 340 IoObject *IoSyslog_priority(IoSyslog *self, IoObject *locals, IoMessage *m)
 341 {
 342         /*#io
 343          docSlot("priority(optionalPriority)", "If optionalPriority is specified, sets the value, and returns it. If no value is specified, will return the previously stored value if one has been set previously.")
 344          */
 345
 346         if (IoMessage_argCount(m) >= 1)
 347         {
 348                 DATA(self)->priority = IOREF(IoMessage_locals_numberArgAt_(m, locals, 0));
 349         }
 350
 351         return DATA(self)->priority;
 352 }
 353
 354 IoObject *IoSyslog_priorityMap(IoSyslog *self, IoObject *locals, IoMessage *m)
 355 {
 356         /*#io
 357          docSlot("priorityMap", "Contains key/value pairs for logging priorities for use when calling the log() method. These include:
 358          <li>LOG_EMERG</li>
 359          <li>LOG_ALERT</li>
 360          <li>LOG_CRIT</li>
 361          <li>LOG_ERR</li>
 362          <li>LOG_WARNING</li>
 363          <li>LOG_NOTICE</li>
 364          <li>LOG_INFO</li>
 365          <li>LOG_DEBUG</li>")
 366          */
 367         PHash *map = IoObject_dataPointer(DATA(self)->priorityMap);
 368         PHash_at_put_(map, IOSYMBOL("LOG_EMERG"), IONUMBER(0));
 369         PHash_at_put_(map, IOSYMBOL("LOG_ALERT"), IONUMBER(1));
 370         PHash_at_put_(map, IOSYMBOL("LOG_CRIT"), IONUMBER(2));
 371         PHash_at_put_(map, IOSYMBOL("LOG_ERR"), IONUMBER(3));
 372         PHash_at_put_(map, IOSYMBOL("LOG_WARNING"), IONUMBER(4));
 373         PHash_at_put_(map, IOSYMBOL("LOG_NOTICE"), IONUMBER(5));
 374         PHash_at_put_(map, IOSYMBOL("LOG_INFO"), IONUMBER(6));
 375         PHash_at_put_(map, IOSYMBOL("LOG_DEBUG"), IONUMBER(7));
 376
 377         return DATA(self)->priorityMap;
 378 }
 379
 380 IoObject *IoSyslog_mask(IoSyslog *self, IoObject *locals, IoMessage *m)
 381 {
 382         /*#io
 383          docSlot("mask(optionalMask)", "If optionalMask is specified, optionalMask is a list which contains any one or more values stored in the maskMap hash that will be OR'd together, to provide the proper mask. Returns the logging mask (as a List).")
 384          */
 385         if (IoMessage_argCount(m) >= 1)
 386         {
 387                 if (!DATA(self)->syslog_opened)
 388                 {
 389                         IoState_error_(IOSTATE, m, "Log must be opened before setting the logging mask");
 390                         return IONIL(self);
 391                 }
 392
 393                 DATA(self)->mask = IOREF(IoMessage_locals_listArgAt_(m, locals, 0));
 394
 395                 {
 396                         List *list = IoList_rawList(DATA(self)->mask);
 397
 398                         LIST_FOREACH(list, i, v,
 399                                 DATA(self)->syslog_mask |= (int)CNUMBER(v);
 400                         );
 401
 402                         setlogmask(DATA(self)->syslog_mask);
 403                 }
 404         }
 405
 406         return DATA(self)->mask;
 407 }
 408
 409 IoObject *IoSyslog_maskMap(IoSyslog *self, IoObject *locals, IoMessage *m)
 410 {
 411         /*#io
 412          docSlot("maskMap", "Contains keys/value pairs which represent numbers that specify the logging mask. These values may be any one (or more) of the following:
 413          <li>LOG_PRIMASK</li>
 414          <li>LOG_FACMASK</li>")
 415          */
 416         PHash *map = IoObject_dataPointer(DATA(self)->maskMap);
 417
 418         PHash_at_put_(map, IOSYMBOL("LOG_PRIMASK"), IONUMBER(0x07));
 419         PHash_at_put_(map, IOSYMBOL("LOG_FACMASK"), IONUMBER(0x03f8));
 420
 421         return DATA(self)->maskMap;
 422 }
 423
 424 IoObject *IoSyslog_log(IoSyslog *self, IoObject *locals, IoMessage *m)
 425 {
 426         /*#io
 427          docSlot("log", "Writes the supplied data to the log. Requires 2 arguments:
 428          <li>Logging Priority</li>
 429          <li>Message to log</li>")
 430          */
 431         char *str;
 432
 433         DATA(self)->priority = IOREF(IoMessage_locals_numberArgAt_(m, locals, 0));
 434         str = CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 1));
 435
 436         if (!DATA(self)->syslog_opened)
 437         {
 438                 IoState_error_(IOSTATE, m, "Log is not opened. Run the open slot before log.");
 439                 return IONIL(self);
 440         }
 441
 442         syslog_write(CNUMBER((int)DATA(self)->priority), str);
 443
 444         return self;
 445 }