1 /*********************************************************** 2 Copyright 1994 by Lance Ellinghouse, 3 Cathedral City, California Republic, United States of America. 4 5 All Rights Reserved 6 7 Permission to use, copy, modify, and distribute this software and its 8 documentation for any purpose and without fee is hereby granted, 9 provided that the above copyright notice appear in all copies and that 10 both that copyright notice and this permission notice appear in 11 supporting documentation, and that the name of Lance Ellinghouse 12 not be used in advertising or publicity pertaining to distribution 13 of the software without specific, written prior permission. 14 15 LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO 16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 17 FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE BE LIABLE FOR ANY SPECIAL, 18 INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 19 FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 20 NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 21 WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 22 23 ******************************************************************/ 24 25 /****************************************************************** 26 27 Revision history: 28 29 2010/04/20 (Sean Reifschneider) 30 - Use basename(sys.argv[0]) for the default "ident". 31 - Arguments to openlog() are now keyword args and are all optional. 32 - syslog() calls openlog() if it hasn't already been called. 33 34 1998/04/28 (Sean Reifschneider) 35 - When facility not specified to syslog() method, use default from openlog() 36 (This is how it was claimed to work in the documentation) 37 - Potential resource leak of o_ident, now cleaned up in closelog() 38 - Minor comment accuracy fix. 39 40 95/06/29 (Steve Clift) 41 - Changed arg parsing to use PyArg_ParseTuple. 42 - Added PyErr_Clear() call(s) where needed. 43 - Fix core dumps if user message contains format specifiers. 44 - Change openlog arg defaults to match normal syslog behavior. 45 - Plug memory leak in openlog(). 46 - Fix setlogmask() to return previous mask value. 47 48 ******************************************************************/ 49 50 /* syslog module */ 51 52 #include "Python.h" 53 #include "osdefs.h" 54 55 #include <syslog.h> 56 57 /* only one instance, only one syslog, so globals should be ok */ 58 static PyObject *S_ident_o = NULL; /* identifier, held by openlog() */ 59 static char S_log_open = 0; 60 61 62 static PyObject * 63 syslog_get_argv(void) 64 { 65 /* Figure out what to use for as the program "ident" for openlog(). 66 * This swallows exceptions and continues rather than failing out, 67 * because the syslog module can still be used because openlog(3) 68 * is optional. 69 */ 70 71 Py_ssize_t argv_len; 72 PyObject *scriptobj; 73 char *atslash; 74 PyObject *argv = PySys_GetObject("argv"); 75 76 if (argv == NULL) { 77 return(NULL); 78 } 79 80 argv_len = PyList_Size(argv); 81 if (argv_len == -1) { 82 PyErr_Clear(); 83 return(NULL); 84 } 85 if (argv_len == 0) { 86 return(NULL); 87 } 88 89 scriptobj = PyList_GetItem(argv, 0); 90 if (!PyString_Check(scriptobj)) { 91 return(NULL); 92 } 93 if (PyString_GET_SIZE(scriptobj) == 0) { 94 return(NULL); 95 } 96 97 atslash = strrchr(PyString_AsString(scriptobj), SEP); 98 if (atslash) { 99 return(PyString_FromString(atslash + 1)); 100 } else { 101 Py_INCREF(scriptobj); 102 return(scriptobj); 103 } 104 105 return(NULL); 106 } 107 108 109 static PyObject * 110 syslog_openlog(PyObject * self, PyObject * args, PyObject *kwds) 111 { 112 long logopt = 0; 113 long facility = LOG_USER; 114 PyObject *new_S_ident_o = NULL; 115 static char *keywords[] = {"ident", "logoption", "facility", 0}; 116 117 if (!PyArg_ParseTupleAndKeywords(args, kwds, 118 "|Sll:openlog", keywords, &new_S_ident_o, &logopt, &facility)) 119 return NULL; 120 121 if (new_S_ident_o) { Py_INCREF(new_S_ident_o); } 122 123 /* get sys.argv[0] or NULL if we can't for some reason */ 124 if (!new_S_ident_o) { 125 new_S_ident_o = syslog_get_argv(); 126 } 127 128 Py_XDECREF(S_ident_o); 129 S_ident_o = new_S_ident_o; 130 131 /* At this point, S_ident_o should be INCREF()ed. openlog(3) does not 132 * make a copy, and syslog(3) later uses it. We can't garbagecollect it 133 * If NULL, just let openlog figure it out (probably using C argv[0]). 134 */ 135 136 openlog(S_ident_o ? PyString_AsString(S_ident_o) : NULL, logopt, facility); 137 S_log_open = 1; 138 139 Py_INCREF(Py_None); 140 return Py_None; 141 } 142 143 144 static PyObject * 145 syslog_syslog(PyObject * self, PyObject * args) 146 { 147 char *message; 148 int priority = LOG_INFO; 149 150 if (!PyArg_ParseTuple(args, "is;[priority,] message string", 151 &priority, &message)) { 152 PyErr_Clear(); 153 if (!PyArg_ParseTuple(args, "s;[priority,] message string", 154 &message)) 155 return NULL; 156 } 157 158 /* if log is not opened, open it now */ 159 if (!S_log_open) { 160 PyObject *openargs; 161 162 /* Continue even if PyTuple_New fails, because openlog(3) is optional. 163 * So, we can still do loggin in the unlikely event things are so hosed 164 * that we can't do this tuple. 165 */ 166 if ((openargs = PyTuple_New(0))) { 167 PyObject *openlog_ret = syslog_openlog(self, openargs, NULL); 168 Py_XDECREF(openlog_ret); 169 Py_DECREF(openargs); 170 } 171 } 172 173 Py_BEGIN_ALLOW_THREADS; 174 syslog(priority, "%s", message); 175 Py_END_ALLOW_THREADS; 176 Py_INCREF(Py_None); 177 return Py_None; 178 } 179 180 static PyObject * 181 syslog_closelog(PyObject *self, PyObject *unused) 182 { 183 if (S_log_open) { 184 closelog(); 185 Py_XDECREF(S_ident_o); 186 S_ident_o = NULL; 187 S_log_open = 0; 188 } 189 Py_INCREF(Py_None); 190 return Py_None; 191 } 192 193 static PyObject * 194 syslog_setlogmask(PyObject *self, PyObject *args) 195 { 196 long maskpri, omaskpri; 197 198 if (!PyArg_ParseTuple(args, "l;mask for priority", &maskpri)) 199 return NULL; 200 omaskpri = setlogmask(maskpri); 201 return PyInt_FromLong(omaskpri); 202 } 203 204 static PyObject * 205 syslog_log_mask(PyObject *self, PyObject *args) 206 { 207 long mask; 208 long pri; 209 if (!PyArg_ParseTuple(args, "l:LOG_MASK", &pri)) 210 return NULL; 211 mask = LOG_MASK(pri); 212 return PyInt_FromLong(mask); 213 } 214 215 static PyObject * 216 syslog_log_upto(PyObject *self, PyObject *args) 217 { 218 long mask; 219 long pri; 220 if (!PyArg_ParseTuple(args, "l:LOG_UPTO", &pri)) 221 return NULL; 222 mask = LOG_UPTO(pri); 223 return PyInt_FromLong(mask); 224 } 225 226 /* List of functions defined in the module */ 227 228 static PyMethodDef syslog_methods[] = { 229 {"openlog", (PyCFunction) syslog_openlog, METH_VARARGS | METH_KEYWORDS}, 230 {"closelog", syslog_closelog, METH_NOARGS}, 231 {"syslog", syslog_syslog, METH_VARARGS}, 232 {"setlogmask", syslog_setlogmask, METH_VARARGS}, 233 {"LOG_MASK", syslog_log_mask, METH_VARARGS}, 234 {"LOG_UPTO", syslog_log_upto, METH_VARARGS}, 235 {NULL, NULL, 0} 236 }; 237 238 /* Initialization function for the module */ 239 240 PyMODINIT_FUNC 241 initsyslog(void) 242 { 243 PyObject *m; 244 245 /* Create the module and add the functions */ 246 m = Py_InitModule("syslog", syslog_methods); 247 if (m == NULL) 248 return; 249 250 /* Add some symbolic constants to the module */ 251 252 /* Priorities */ 253 PyModule_AddIntConstant(m, "LOG_EMERG", LOG_EMERG); 254 PyModule_AddIntConstant(m, "LOG_ALERT", LOG_ALERT); 255 PyModule_AddIntConstant(m, "LOG_CRIT", LOG_CRIT); 256 PyModule_AddIntConstant(m, "LOG_ERR", LOG_ERR); 257 PyModule_AddIntConstant(m, "LOG_WARNING", LOG_WARNING); 258 PyModule_AddIntConstant(m, "LOG_NOTICE", LOG_NOTICE); 259 PyModule_AddIntConstant(m, "LOG_INFO", LOG_INFO); 260 PyModule_AddIntConstant(m, "LOG_DEBUG", LOG_DEBUG); 261 262 /* openlog() option flags */ 263 PyModule_AddIntConstant(m, "LOG_PID", LOG_PID); 264 PyModule_AddIntConstant(m, "LOG_CONS", LOG_CONS); 265 PyModule_AddIntConstant(m, "LOG_NDELAY", LOG_NDELAY); 266 #ifdef LOG_NOWAIT 267 PyModule_AddIntConstant(m, "LOG_NOWAIT", LOG_NOWAIT); 268 #endif 269 #ifdef LOG_PERROR 270 PyModule_AddIntConstant(m, "LOG_PERROR", LOG_PERROR); 271 #endif 272 273 /* Facilities */ 274 PyModule_AddIntConstant(m, "LOG_KERN", LOG_KERN); 275 PyModule_AddIntConstant(m, "LOG_USER", LOG_USER); 276 PyModule_AddIntConstant(m, "LOG_MAIL", LOG_MAIL); 277 PyModule_AddIntConstant(m, "LOG_DAEMON", LOG_DAEMON); 278 PyModule_AddIntConstant(m, "LOG_AUTH", LOG_AUTH); 279 PyModule_AddIntConstant(m, "LOG_LPR", LOG_LPR); 280 PyModule_AddIntConstant(m, "LOG_LOCAL0", LOG_LOCAL0); 281 PyModule_AddIntConstant(m, "LOG_LOCAL1", LOG_LOCAL1); 282 PyModule_AddIntConstant(m, "LOG_LOCAL2", LOG_LOCAL2); 283 PyModule_AddIntConstant(m, "LOG_LOCAL3", LOG_LOCAL3); 284 PyModule_AddIntConstant(m, "LOG_LOCAL4", LOG_LOCAL4); 285 PyModule_AddIntConstant(m, "LOG_LOCAL5", LOG_LOCAL5); 286 PyModule_AddIntConstant(m, "LOG_LOCAL6", LOG_LOCAL6); 287 PyModule_AddIntConstant(m, "LOG_LOCAL7", LOG_LOCAL7); 288 289 #ifndef LOG_SYSLOG 290 #define LOG_SYSLOG LOG_DAEMON 291 #endif 292 #ifndef LOG_NEWS 293 #define LOG_NEWS LOG_MAIL 294 #endif 295 #ifndef LOG_UUCP 296 #define LOG_UUCP LOG_MAIL 297 #endif 298 #ifndef LOG_CRON 299 #define LOG_CRON LOG_DAEMON 300 #endif 301 302 PyModule_AddIntConstant(m, "LOG_SYSLOG", LOG_SYSLOG); 303 PyModule_AddIntConstant(m, "LOG_CRON", LOG_CRON); 304 PyModule_AddIntConstant(m, "LOG_UUCP", LOG_UUCP); 305 PyModule_AddIntConstant(m, "LOG_NEWS", LOG_NEWS); 306 } 307
