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, scriptlen; 72 PyObject *scriptobj; 73 Py_ssize_t slash; 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 (!PyUnicode_Check(scriptobj)) { 91 return(NULL); 92 } 93 scriptlen = PyUnicode_GET_LENGTH(scriptobj); 94 if (scriptlen == 0) { 95 return(NULL); 96 } 97 98 slash = PyUnicode_FindChar(scriptobj, SEP, 0, scriptlen, -1); 99 if (slash == -2) 100 return NULL; 101 if (slash != -1) { 102 return PyUnicode_Substring(scriptobj, slash, scriptlen); 103 } else { 104 Py_INCREF(scriptobj); 105 return(scriptobj); 106 } 107 108 return(NULL); 109 } 110 111 112 static PyObject * 113 syslog_openlog(PyObject * self, PyObject * args, PyObject *kwds) 114 { 115 long logopt = 0; 116 long facility = LOG_USER; 117 PyObject *new_S_ident_o = NULL; 118 static char *keywords[] = {"ident", "logoption", "facility", 0}; 119 char *ident = NULL; 120 121 if (!PyArg_ParseTupleAndKeywords(args, kwds, 122 "|Ull:openlog", keywords, &new_S_ident_o, &logopt, &facility)) 123 return NULL; 124 125 if (new_S_ident_o) { 126 Py_INCREF(new_S_ident_o); 127 } 128 129 /* get sys.argv[0] or NULL if we can't for some reason */ 130 if (!new_S_ident_o) { 131 new_S_ident_o = syslog_get_argv(); 132 } 133 134 Py_XDECREF(S_ident_o); 135 S_ident_o = new_S_ident_o; 136 137 /* At this point, S_ident_o should be INCREF()ed. openlog(3) does not 138 * make a copy, and syslog(3) later uses it. We can't garbagecollect it 139 * If NULL, just let openlog figure it out (probably using C argv[0]). 140 */ 141 if (S_ident_o) { 142 ident = PyUnicode_AsUTF8(S_ident_o); 143 if (ident == NULL) 144 return NULL; 145 } 146 147 openlog(ident, logopt, facility); 148 S_log_open = 1; 149 150 Py_INCREF(Py_None); 151 return Py_None; 152 } 153 154 155 static PyObject * 156 syslog_syslog(PyObject * self, PyObject * args) 157 { 158 PyObject *message_object; 159 const char *message; 160 int priority = LOG_INFO; 161 162 if (!PyArg_ParseTuple(args, "iU;[priority,] message string", 163 &priority, &message_object)) { 164 PyErr_Clear(); 165 if (!PyArg_ParseTuple(args, "U;[priority,] message string", 166 &message_object)) 167 return NULL; 168 } 169 170 message = PyUnicode_AsUTF8(message_object); 171 if (message == NULL) 172 return NULL; 173 174 /* if log is not opened, open it now */ 175 if (!S_log_open) { 176 PyObject *openargs; 177 178 /* Continue even if PyTuple_New fails, because openlog(3) is optional. 179 * So, we can still do loggin in the unlikely event things are so hosed 180 * that we can't do this tuple. 181 */ 182 if ((openargs = PyTuple_New(0))) { 183 PyObject *openlog_ret = syslog_openlog(self, openargs, NULL); 184 Py_XDECREF(openlog_ret); 185 Py_DECREF(openargs); 186 } 187 } 188 189 Py_BEGIN_ALLOW_THREADS; 190 syslog(priority, "%s", message); 191 Py_END_ALLOW_THREADS; 192 Py_RETURN_NONE; 193 } 194 195 static PyObject * 196 syslog_closelog(PyObject *self, PyObject *unused) 197 { 198 if (S_log_open) { 199 closelog(); 200 Py_CLEAR(S_ident_o); 201 S_log_open = 0; 202 } 203 Py_INCREF(Py_None); 204 return Py_None; 205 } 206 207 static PyObject * 208 syslog_setlogmask(PyObject *self, PyObject *args) 209 { 210 long maskpri, omaskpri; 211 212 if (!PyArg_ParseTuple(args, "l;mask for priority", &maskpri)) 213 return NULL; 214 omaskpri = setlogmask(maskpri); 215 return PyLong_FromLong(omaskpri); 216 } 217 218 static PyObject * 219 syslog_log_mask(PyObject *self, PyObject *args) 220 { 221 long mask; 222 long pri; 223 if (!PyArg_ParseTuple(args, "l:LOG_MASK", &pri)) 224 return NULL; 225 mask = LOG_MASK(pri); 226 return PyLong_FromLong(mask); 227 } 228 229 static PyObject * 230 syslog_log_upto(PyObject *self, PyObject *args) 231 { 232 long mask; 233 long pri; 234 if (!PyArg_ParseTuple(args, "l:LOG_UPTO", &pri)) 235 return NULL; 236 mask = LOG_UPTO(pri); 237 return PyLong_FromLong(mask); 238 } 239 240 /* List of functions defined in the module */ 241 242 static PyMethodDef syslog_methods[] = { 243 {"openlog", (PyCFunction) syslog_openlog, METH_VARARGS | METH_KEYWORDS}, 244 {"closelog", syslog_closelog, METH_NOARGS}, 245 {"syslog", syslog_syslog, METH_VARARGS}, 246 {"setlogmask", syslog_setlogmask, METH_VARARGS}, 247 {"LOG_MASK", syslog_log_mask, METH_VARARGS}, 248 {"LOG_UPTO", syslog_log_upto, METH_VARARGS}, 249 {NULL, NULL, 0} 250 }; 251 252 /* Initialization function for the module */ 253 254 255 static struct PyModuleDef syslogmodule = { 256 PyModuleDef_HEAD_INIT, 257 "syslog", 258 NULL, 259 -1, 260 syslog_methods, 261 NULL, 262 NULL, 263 NULL, 264 NULL 265 }; 266 267 PyMODINIT_FUNC 268 PyInit_syslog(void) 269 { 270 PyObject *m; 271 272 /* Create the module and add the functions */ 273 m = PyModule_Create(&syslogmodule); 274 if (m == NULL) 275 return NULL; 276 277 /* Add some symbolic constants to the module */ 278 279 /* Priorities */ 280 PyModule_AddIntMacro(m, LOG_EMERG); 281 PyModule_AddIntMacro(m, LOG_ALERT); 282 PyModule_AddIntMacro(m, LOG_CRIT); 283 PyModule_AddIntMacro(m, LOG_ERR); 284 PyModule_AddIntMacro(m, LOG_WARNING); 285 PyModule_AddIntMacro(m, LOG_NOTICE); 286 PyModule_AddIntMacro(m, LOG_INFO); 287 PyModule_AddIntMacro(m, LOG_DEBUG); 288 289 /* openlog() option flags */ 290 PyModule_AddIntMacro(m, LOG_PID); 291 PyModule_AddIntMacro(m, LOG_CONS); 292 PyModule_AddIntMacro(m, LOG_NDELAY); 293 #ifdef LOG_ODELAY 294 PyModule_AddIntMacro(m, LOG_ODELAY); 295 #endif 296 #ifdef LOG_NOWAIT 297 PyModule_AddIntMacro(m, LOG_NOWAIT); 298 #endif 299 #ifdef LOG_PERROR 300 PyModule_AddIntMacro(m, LOG_PERROR); 301 #endif 302 303 /* Facilities */ 304 PyModule_AddIntMacro(m, LOG_KERN); 305 PyModule_AddIntMacro(m, LOG_USER); 306 PyModule_AddIntMacro(m, LOG_MAIL); 307 PyModule_AddIntMacro(m, LOG_DAEMON); 308 PyModule_AddIntMacro(m, LOG_AUTH); 309 PyModule_AddIntMacro(m, LOG_LPR); 310 PyModule_AddIntMacro(m, LOG_LOCAL0); 311 PyModule_AddIntMacro(m, LOG_LOCAL1); 312 PyModule_AddIntMacro(m, LOG_LOCAL2); 313 PyModule_AddIntMacro(m, LOG_LOCAL3); 314 PyModule_AddIntMacro(m, LOG_LOCAL4); 315 PyModule_AddIntMacro(m, LOG_LOCAL5); 316 PyModule_AddIntMacro(m, LOG_LOCAL6); 317 PyModule_AddIntMacro(m, LOG_LOCAL7); 318 319 #ifndef LOG_SYSLOG 320 #define LOG_SYSLOG LOG_DAEMON 321 #endif 322 #ifndef LOG_NEWS 323 #define LOG_NEWS LOG_MAIL 324 #endif 325 #ifndef LOG_UUCP 326 #define LOG_UUCP LOG_MAIL 327 #endif 328 #ifndef LOG_CRON 329 #define LOG_CRON LOG_DAEMON 330 #endif 331 332 PyModule_AddIntMacro(m, LOG_SYSLOG); 333 PyModule_AddIntMacro(m, LOG_CRON); 334 PyModule_AddIntMacro(m, LOG_UUCP); 335 PyModule_AddIntMacro(m, LOG_NEWS); 336 337 #ifdef LOG_AUTHPRIV 338 PyModule_AddIntMacro(m, LOG_AUTHPRIV); 339 #endif 340 341 return m; 342 } 343