def main(): pids = [proc for proc in os.listdir('/proc') if proc.isdigit()] # UIDs that have a listed process cleanup = set() # UIDs that have a non-listed process dont_cleanup = set() for proc in pids: try: status = open(os.path.join('/proc', proc, 'status'), 'r') except IOError: continue for line in status: elements = line.split(':') if elements[0] == 'Uid': uids = elements[1].split() real_uid = uids[0].strip() if elements[0] == 'Name': proc_name = elements[1].strip() if int(real_uid) > 1000: if proc_name in CHECK_FOR: cleanup.add(real_uid) if proc_name not in CHECK_FOR: dont_cleanup.add(real_uid) for uid in cleanup: if uid not in dont_cleanup: subprocess.call(['pkill', '-u', uid]) syslog.openlog(ident='x2go_cleanup_processes', logoption=syslog.LOG_PID, facility=syslog.LOG_USER) syslog.syslog(syslog.LOG_NOTICE, 'Cleaning up processes for {0}'.format(uid)) syslog.closelog()
def _log_syslog(self, prio): if self.__ident: syslog.openlog(ident=self.__ident, facility=self.__fac) syslog.syslog(prio, self.__last_message) syslog.closelog() else: syslog.syslog(prio | self.__fac, self.__last_message)
def returner(ret): ''' Return data to the local syslog ''' _options = _get_options(ret) if not _verify_options(_options): return # Get values from syslog module level = getattr(syslog, _options['level']) facility = getattr(syslog, _options['facility']) # parse for syslog options logoption = 0 for opt in _options['options']: logoption = logoption | getattr(syslog, opt) # Open syslog correctly based on options and tag if 'tag' in _options: syslog.openlog(ident=_options['tag'], logoption=logoption) else: syslog.openlog(logoption=logoption) # Send log of given level and facility syslog.syslog(facility | level, '{0}'.format(json.dumps(ret))) # Close up to reset syslog to defaults syslog.closelog()
def emit(self, record): hand = syslog.openlog(facility=self.facility) msg = self.format(record) syslog.syslog( self.priority_names.get(record.levelname.lower(), "debug"), msg) syslog.closelog()
def debug(*args): msg = make_msg(args) if sys.stderr.isatty(): logging.debug(msg) syslog.openlog(ident, syslog.LOG_NDELAY, facility) syslog.syslog(syslog.LOG_DEBUG, msg) syslog.closelog()
def log(self, msg=''): if msg != '': sys.stdout.write(self.script_path + ': ' + str(msg) + '\n') syslog.openlog(ident='openvpn ' + self.name + ' ' + self.instance, logoption=0, facility=syslog.LOG_DAEMON) syslog.syslog(syslog.LOG_INFO, msg) syslog.closelog()
def send_10_log_messages_with_delay(): syslog.openlog(logoption=syslog.LOG_PID, facility=syslog.LOG_MAIL) for ind in range(10): msg = str(ind + 1) + '. Test Syslog Messages being sent.' syslog.syslog(syslog.LOG_EMERG, msg) time.sleep(1) syslog.closelog()
def send_test_log_message(): syslog.openlog(logoption=syslog.LOG_PID, facility=syslog.LOG_KERN) for ind in range(5): msg = str(ind + 1) + '. Test Syslog Messages from different nodes.' syslog.syslog(syslog.LOG_EMERG, msg) time.sleep(1) syslog.closelog()
def log(msg, level=syslog.LOG_NOTICE): if USE_STDERR: print >> sys.stderr, msg else: syslog.openlog( 'xs-activity-server', 0, syslog.LOG_USER ) syslog.syslog(level, msg) syslog.closelog()
def send_messages_of_all_facility_and_severity(): dict_of_facility = { 'LOG_KERN': 0, 'LOG_USER': 1, 'LOG_MAIL': 2, 'LOG_DAEMON': 3, 'LOG_AUTH': 4, 'LOG_NEWS': 7, 'LOG_UUCP': 8, 'LOG_LOCAL0': 16, 'LOG_CRON': 15, 'LOG_SYSLOG': 5, 'LOG_LOCAL1': 17} list_of_severity = ['LOG_EMERG', 'LOG_ALERT', 'LOG_CRIT', 'LOG_ERR', 'LOG_WARNING', 'LOG_NOTICE', 'LOG_INFO', 'LOG_DEBUG'] for each_facility in dict_of_facility: log_facility = dict_of_facility[each_facility] syslog.openlog(logoption=syslog.LOG_PID, facility=log_facility) for each_severity in list_of_severity: log_severity = list_of_severity.index(each_severity) msg = 'Test Message from ' + each_facility + \ ' with severity ' + each_severity + '.' syslog.syslog(log_severity, msg) syslog.closelog() time.sleep(1)
def main ():#funcion principal logs = open("FilesOutput/CompleteTables_Logs_error.txt", 'w')#se abre archivo log #abrimos syslog para registrar lo que realiza el script... syslog.openlog("CompleteTables.py", syslog.LOG_USER) syslog.syslog(syslog.LOG_INFO,"this script has created the next output files CompleteTables_Logs_error.txt") information_DB = ReadCSV(sys.argv[1])#obtenemos la informacion de la base de datos... syslog.syslog(syslog.LOG_INFO, "Completando datos en tablas no relacionadas") #se generan las conexiones data_connected_import = ConnectDB(information_DB['import'][0], information_DB['import'][1], information_DB['import'][2], information_DB['import'][3]) data_connected_export = ConnectDB(information_DB['export'][0], information_DB['export'][1], information_DB['export'][2], information_DB['export'][3]) #se realiza el mismo proceso para las diferentes tablas... #insertando elementos tabla tipodispositivo CompleteProcessInsertion(data_connected_export[1], data_connected_export[0], data_connected_import[1], data_connected_import[0], "tipo_dispositivo", "tipodispositivo", "tipo", "tipodispositivo_id_seq", 1) #insertando elementos tabla marca CompleteProcessInsertion(data_connected_export[1], data_connected_export[0], data_connected_import[1], data_connected_import[0], "marca", "marca", "marca", "marca_id_seq", 1) #insertando elementos tabla tipousuario CompleteProcessInsertion(data_connected_export[1], data_connected_export[0], data_connected_import[1], data_connected_import[0], "tipo_usuario", "tipousuario", "tipo", "tipousuario_id_seq", 0) #insertando elementos tabla estadodispositivo and tabla estadousuario CompleteProcessInsertion(data_connected_export[1], data_connected_export[0], data_connected_import[1], data_connected_import[0], "estado", "estadodispositivo", "descripcion", "estadodispositivo_id_seq", 1) logs.write("ok") logs.close() syslog.closelog()#cerramos syslog return 0
def main (): #abrimos syslog para registrar lo que realiza el script... syslog.openlog("VerificaRequisitos.py", syslog.LOG_USER) #abrimos archivo de texto con la informacion de la conexion... file_verificacion = open("FilesOutput/Verificacion.txt", 'w')#con w para crearlo #recibimos los argumentos data_import = sys.argv[2].split('_') data_export = sys.argv[1].split('_') syslog.syslog(syslog.LOG_INFO,"Verificando las conexiones a la base de datos") #hacemos la llamada a la funcion... Verificacion(data_export[0],data_export[1], data_export[2], data_export[3])#verificamos la conexion a la base de datos export Verificacion(data_import[0], data_import[1], data_import[2], data_import[3])#verificamos la conexion a la base de datos import #hacemos la verificacion de usuario root... usuario_root = VerificaUsuario() if (usuario_root == "ok"): file_verificacion.write("ok")#si todos los procesos terminan de ejecutarse de manera correcta simplemente se escribe un ok para el archivo else: file_verificacion.write("no")#hubo algun problema syslog.closelog()#cerramos syslog
def _log(priority, msg): syslog.openlog("slander", logoption=syslog.LOG_PID) syslog.syslog(priority, msg) syslog.closelog() if sys.stdout.isatty(): print(msg)
def warning(*args): msg = make_msg(args) if sys.stderr.isatty(): logging.warning(msg) syslog.openlog(ident, syslog.LOG_NDELAY, facility) syslog.syslog(syslog.LOG_WARNING, msg) syslog.closelog()
def main (): #abrimos syslog para registrar lo que realiza el script... syslog.openlog("RemoveElementsConflictiv.py", syslog.LOG_USER) information_DB = ReadCSV(sys.argv[1])#obtenemos la informacion de la base de datos... # #make connections... data_connected_import = ConnectDB(information_DB['import'][0], information_DB['import'][1], information_DB['import'][2], information_DB['import'][3]) data_connected_export = ConnectDB(information_DB['export'][0], information_DB['export'][1], information_DB['export'][2], information_DB['export'][3]) print "Removiendo elementos conflictivos y elementos no existentes en csv" #obtengo la lista de macs... list_macs = ReadText("FilesOutput/GetMacslist_macs_not_exists.txt") list_macs_persistentes=RemoveMacsNotInCSV(data_connected_export[1], data_connected_export[0], list_macs) #eliminamos los datos que presentan problemas de union y que deben almacenar su informacion en un csv... list_equipos_conflictivos = GetListEquiposConflictivos(data_connected_export[1], data_connected_export[0])#obtenemos la lista de elementos conflictivos... info_equipos_conflictivos = RecolectaInformacionEquiposConflictivos(data_connected_export[1], list_equipos_conflictivos) GenerateCSV(info_equipos_conflictivos, data_connected_import[1]) DeleteEquiposConflictivos(data_connected_export[1], data_connected_export[0], list_equipos_conflictivos) logs = open("FilesOutput/Remove.txt", 'w') logs.write("ok") logs.close() syslog.closelog()#cerramos syslog return 0
def syslog(message, ident = "", priority = "info", facility = "syslog", options = []): """ Send a string to syslog and return that same string. """ priority = { "emerg":SYSLOG.LOG_EMERG, "alert":SYSLOG.LOG_ALERT, "crit":SYSLOG.LOG_CRIT, "err":SYSLOG.LOG_ERR, "warning":SYSLOG.LOG_WARNING, "notice":SYSLOG.LOG_NOTICE, "info":SYSLOG.LOG_INFO, "debug":SYSLOG.LOG_DEBUG }.get(str(priority).lower(),0) facility = { "kern":SYSLOG.LOG_KERN, "user":SYSLOG.LOG_USER, "mail":SYSLOG.LOG_MAIL, "daemon":SYSLOG.LOG_DAEMON, "auth":SYSLOG.LOG_AUTH, "lpr":SYSLOG.LOG_LPR, "news":SYSLOG.LOG_NEWS, "uucp":SYSLOG.LOG_UUCP, "cron":SYSLOG.LOG_CRON, "syslog":SYSLOG.LOG_SYSLOG, "local0":SYSLOG.LOG_LOCAL0, "local1":SYSLOG.LOG_LOCAL1, "local2":SYSLOG.LOG_LOCAL2, "local3":SYSLOG.LOG_LOCAL3, "local4":SYSLOG.LOG_LOCAL4, "local5":SYSLOG.LOG_LOCAL5, "local6":SYSLOG.LOG_LOCAL6, "local7":SYSLOG.LOG_LOCAL7 }.get(str(facility).lower(),0) option = 0 for opt in options: option += { "pid":SYSLOG.LOG_PID, "cons":SYSLOG.LOG_CONS, "ndelay":SYSLOG.LOG_NDELAY, "nowait":SYSLOG.LOG_NOWAIT, "perror":SYSLOG.LOG_PERROR }.get(str(opt).lower(),0) message = str(message) ident = str(ident) if not ident: ident = os.path.basename(sys.argv[0]) SYSLOG.openlog(ident = ident, logoption = option, facility = facility) add = "" for line in message.split("\n"): if line: SYSLOG.syslog(priority, add + line) add = " " SYSLOG.closelog() return message
def close(self): """ Closes the handler. """ syslog.closelog() logging.Handler.close(self)
def log(self, msg, priority=None): """ Log an message string with a certain priority string. If that priority is greater than the pre-defined min priority log the message to /var/log/messages. The priority string must be one of EMERG, ALERT, CRIT, ERR, WARNING, NOTICE, INFO, DEBUG args : msg ... message to be logged priority ... priority of the msg EMERG, ALERT, CRIT, ERR, WARNING, NOTICE, INFO or DEBUG excepts : return : none """ # 'priority' is the actual level of the event, it must be one of ... # EMERG, ALERT, CRIT, ERR, WARNING, NOTICE, INFO, DEBUG # 'msg' will only be sent to syslog if 'priority' >= 'min_priority' # TODO: The Python syslog module is very broken - logging priorities are # ignored, this is a workaround ... if priority is None: priority = Logger.NOTICE msg = "{0}: [{1}] {2}".format(priority, self.module, msg) if self.case[priority] <= self.case[self.min_priority]: syslog.openlog(self.program, syslog.LOG_PID) syslog.syslog(msg) syslog.closelog()
def log_error(msg, syslog_identifier, also_print_to_console=False): syslog.openlog(syslog_identifier) syslog.syslog(syslog.LOG_ERR, msg) syslog.closelog() if also_print_to_console: print msg
def zlogFinal(success, config): global EBUFFER gconfig = config['global'] if SYSLOG: syslog.closelog() if EMAIL: if success: ss = "SUCCESS" else: ss = "FAILURE" now = datetime.datetime.now() fromaddr = gconfig['email:from'] toaddr = gconfig['email:to'] smtpsrv = gconfig['email:smtpsrv'] subject = "zbackup Report: %02d/%02d/%04d %02d:%02d (%s)" % (now.month, now.day, now.year, now.hour, now.minute, ss) body = ''.join(EBUFFER) msg = '\n'.join([ "From: %s" % fromaddr, "To: %s" % toaddr, "Subject: %s" % subject, "", body]) zloginfo("Sending email report to %s" % toaddr) s = smtplib.SMTP(smtpsrv) s.sendmail(fromaddr, [toaddr], msg) s.quit() EBUFFER = []
def log(msg): """ Send a message to syslog """ syslog.openlog('OpenVPN', 0, syslog.LOG_DAEMON) syslog.syslog(syslog.LOG_INFO, msg) syslog.closelog()
def log_cef(self, message_name, message_description, type='LOG_INFO', items=[]): """ log_cef method to actually write message to syslog param: message_name - Generic name of message type param: message_description - More verbose details of the message to be logged param: type - A string representation of the syslog facility, LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR, LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG http://unix.superglobalmegacorp.com/Net2/newsrc/sys/syslog.h.html param: items - List of cef specific key/value pairs typical usage: """ # Open a connection to syslog to the proper facility syslog.openlog(self.prog_name, 0, self.facility) label_string = '' # Iterating over the items list and construct the label string to send for row in items: for key, value in row.items(): label_string = "%s%s=%s " % ( label_string, str(key), str(value)) cefmsg = 'CEF:0|Mozilla|%s|1.0|%s|%s|5|%s dhost=%s' %\ (self.prog_name, message_name, message_description, label_string, os.uname()[1]) try: syslog_level = getattr(syslog, type) except AttributeError: raise BaseException('Unable to find syslog type') syslog.syslog(syslog_level, cefmsg) syslog.closelog()
def log(txt, force=False): global log, log_enabled if not log_enabled and not force: return syslog.openlog("skolesys-backup") syslog.syslog(txt) syslog.closelog()
def log_warning(msg, also_print_to_console=False): syslog.openlog(SYSLOG_IDENTIFIER) syslog.syslog(syslog.LOG_WARNING, msg) syslog.closelog() if also_print_to_console: click.echo(msg)
def log_error(msg, also_print_to_console=False): syslog.openlog(SYSLOG_IDENTIFIER) syslog.syslog(syslog.LOG_ERR, msg) syslog.closelog() if also_print_to_console: click.echo(msg)
def error(*args): msg = make_msg(args) if sys.stderr.isatty(): logging.error(msg) syslog.openlog(ident, syslog.LOG_NDELAY, facility) syslog.syslog(syslog.LOG_ERR, msg) syslog.closelog()
def main(): parser = OptionParser() parser.add_option('-W', '--warning', action='store', dest='warning', default=100, type='int', help='The warning threshold we want to set') parser.add_option('-C', '--critical', action='store', dest='critical', default=200, type='int', help='The critical threshold we want to set') (options, args) = parser.parse_args() start = time.time() # syslog check start syslog.openlog( 'check_syslog' ) syslog.syslog( syslog.LOG_DEBUG, 'Nagion syslog check' ) syslog.closelog() # syslog check stop stop = time.time() result = int((stop - start) * 1000) if(result < options.warning): print "OK - %d ms" % result return 0 if(result < options.critical): print "WARNING - %d ms" % result return 1 else: print "CRITICAL - %d ms" % result return 2
def exception(): msg = traceback.format_exc() if sys.stderr.isatty(): logging.error(msg) syslog.openlog(ident, syslog.LOG_NDELAY, facility) syslog.syslog(syslog.LOG_ERR, msg) syslog.closelog()
def log_warning(msg, syslog_identifier, also_print_to_console=False): syslog.openlog(syslog_identifier) syslog.syslog(syslog.LOG_WARNING, msg) syslog.closelog() if also_print_to_console: print msg
def log(statement, event=False): statement = str(statement) # Always print event related messages, even when --quiet is specified if options.quiet is True and event is False: return # Always log to syslog syslog.openlog("ha-nat") syslog.syslog(statement) syslog.closelog() # Always print to stdout print statement # Log to a file if one has been specified if options.logFile is not None: if not os.path.exists(os.path.dirname(options.logFile)): os.makedirs(os.path.dirname(options.logFile)) logFile = open(options.logFile, 'a') ts = datetime.datetime.now() isFirst = True for line in statement.split("\n"): if isFirst: logFile.write("%s - %s\n" % (ts, line)) isFirst = False else: logFile.write("%s - %s\n" % (ts, line)) logFile.close()
def postClientDataToSysLog(client_obj): # Collection for Syslog and Splunk syslog.openlog(facility=syslog.LOG_DAEMON) dataStr = "client_id: {}, hostname: {}, ip: {}, mac_address: {}, fileVault_status: {}, os_ver: {}, loggedin_user: {}".format( client_obj.cuuid, client_obj.hostname, client_obj.ipaddr, client_obj.macaddr, client_obj.fileVaultStatus, client_obj.osver, client_obj.consoleuser) syslog.syslog(dataStr) syslog.closelog() log_Info("Wrote to syslog: " + dataStr) return
def run_module(): # define the available arguments/parameters that a user can pass to # the module module_args = dict(msg=dict(type='str', required=True), priority=dict(type='str', required=False, choices=[ "emerg", "alert", "crit", "err", "warning", "notice", "info", "debug" ], default='info'), facility=dict(type='str', required=False, choices=[ "kern", "user", "mail", "daemon", "auth", "lpr", "news", "uucp", "cron", "syslog", "local0", "local1", "local2", "local3", "local4", "local5", "local6", "local7" ], default='daemon'), log_pid=dict(type='bool', required=False, default=False)) module = AnsibleModule(argument_spec=module_args, supports_check_mode=True) result = dict(changed=False, priority=module.params['priority'], facility=module.params['facility'], log_pid=module.params['log_pid'], msg=module.params['msg']) # basically, do nothing. if module.check_mode: return result # do the logging try: if module.params['log_pid']: syslog.openlog('ansible_syslogger', logoption=syslog.LOG_PID, facility=get_facility(module.params['facility'])) else: syslog.openlog('ansible_syslogger', facility=get_facility(module.params['facility'])) syslog.syslog(get_priority(module.params['priority']), module.params['msg']) syslog.closelog() result['changed'] = True except: module.fail_json(error='Failed to write to syslog', **result) module.exit_json(**result)
def sysLog(self, debug=syslog.LOG_INFO, msg=None, doPrint=False): # log debug only if enabled if self.DEBUG == False and debug == syslog.LOG_DEBUG: return if doPrint and self.print_log_enabled: print("{}({}):{}".format(self.SYSLOG_IDENTIFIER, debug, msg)) syslog.openlog(self.SYSLOG_IDENTIFIER) syslog.syslog(debug, msg) syslog.closelog() return
def SendNotice(Message): try: syslog.openlog("genmon") syslog.syslog("%s" % Message) syslog.closelog() except Exception as e1: log.error("Error: " + str(e1)) print("Error: " + str(e1))
def _syslog(self, facility, level, ident, message): _syslog.openlog(ident, facility) if isinstance(message, basestring): _syslog.syslog(_MLOG_TO_SYSLOG[level], message) else: try: for m in message: _syslog.syslog(_MLOG_TO_SYSLOG[level], m) except TypeError: _syslog.syslog(_MLOG_TO_SYSLOG[level], str(message)) _syslog.closelog()
def send_messages_grater_than_1024_bytes(): syslog.openlog(logoption=syslog.LOG_PID, facility=syslog.LOG_MAIL) with open("message.txt", "r") as myfile: msg = myfile.readlines()[0] myfile.close() for ind in range(100): syslog.syslog(syslog.LOG_EMERG, (msg[:5] + str(ind) + 'mymark' + msg[6:])) time.sleep(1) syslog.closelog()
def _log(message, priority, verbose): tag = { syslog.LOG_INFO: "INFO", syslog.LOG_WARNING: "WARNING", syslog.LOG_ERR: "ERROR", syslog.LOG_DEBUG: "DEBUG" } if verbose: sys.stderr.write("{}: {}\n".format(tag[priority], message)) syslog.openlog(facility=syslog.LOG_SYSLOG) syslog.syslog(priority, message) syslog.closelog()
def audit_log(msg): """Make an audit syslog, splitting up the request as required to prevent it being dropped or truncated""" lines = msg.split("\n") syslog.openlog("audit-log", syslog.LOG_PID, facility=syslog.LOG_AUTH) for line in lines: syslog.syslog(syslog.LOG_NOTICE, line.encode("utf-8")) syslog.closelog()
def main(): sc = cachedStatusObj('obs.sum.subaru.nao.ac.jp') syslog.openlog("SOSSstatusServer", syslog.LOG_PID, syslog.LOG_WARNING | syslog.LOG_DAEMON) while True: line = sys.stdin.readline() if line == "": break aliasname = line.strip(' \r\n') val = sc.get_statusValue(aliasname) sys.stderr.write(str(val) + "\n") syslog.closelog()
def auth_log(message, priority=syslog.LOG_INFO): """ Sends errors to default authentication log @param string message @param integer priority @return void """ syslog.openlog(facility=syslog.LOG_AUTH) syslog.syslog(priority, 'PAM RFID: ' + message) syslog.closelog()
def logging(priority, message): """Logging. Arguments: priority: syslog priority message: log message """ syslog.openlog(backup2swift.__name__, syslog.LOG_PID, syslog.LOG_LOCAL0) syslog.syslog(priority, str(message)) syslog.closelog() print(message) exit(1)
def incoming(self, attackerIP, attackerPort, victimIP, victimPort, vulnName, timestamp, downloadMethod, loLogger, attackerID, shellcodeName): try: self.log_obj = amun_logging.amun_logging("log_syslog", loLogger) syslog_message = "Exploit: %s -> %s:%s %s (%s)" % ( attackerIP, victimIP, victimPort, vulnName, downloadMethod) syslog.openlog('Amun', syslog.LOG_PID, syslog.LOG_LOCAL4) syslog.syslog(syslog.LOG_WARNING, syslog_message) syslog.closelog() except KeyboardInterrupt: raise
def close(): """Closes all handles. Invoke this before you exit your app """ global logger, pid, process_name, inited, config, engine, conn, connected, levels, priorities, config_table, log_table, meta, log_fname, log_fhandle if conn: conn.close() if engine: engine.dispose() syslog.closelog() if (log_fhandle): log_fhandle.close() inited = False
def exitError(self, msg): """ Return to shell with an exit status 1 and the given message. """ sys.stderr.write(msg) syslog.openlog("ace") # we don't have a logger yet ... syslog.syslog( syslog.LOG_ERR, "Can't start correlation engine (invalid configuration file): " + msg) syslog.closelog() sys.exit(1)
def logging(priority, message): """ Arguments: priority: syslog priority message: log message """ syslog.openlog(NAME, syslog.LOG_PID, syslog.LOG_LOCAL0) syslog.syslog(priority, str(message)) syslog.closelog() print(message) exit(1)
def process(mysettings, key, logentries, fulltext): syslog.openlog("portage", syslog.LOG_ERR | syslog.LOG_WARNING | syslog.LOG_INFO | syslog.LOG_NOTICE, syslog.LOG_LOCAL5) for phase in EBUILD_PHASES: if not phase in logentries: continue for msgtype, msgcontent in logentries[phase]: if isinstance(msgcontent, str): msgcontent = [msgcontent] for line in msgcontent: line = "%s: %s: %s" % (key, phase, line) syslog.syslog(_pri[msgtype], line.rstrip("\n")) syslog.closelog()
async def do_update(self, data): """ Update settings of SSH daemon service. If `bindiface` is empty it will listen for all available addresses. .. examples(websocket):: Make sshd listen only to igb0 interface. :::javascript { "id": "6841f242-840a-11e6-a437-00e04d680384", "msg": "method", "method": "ssh.update", "params": [{ "bindiface": ["igb0"] }] } """ old = await self.config() new = old.copy() new.update(data) if new['bindiface']: verrors = ValidationErrors() iface_choices = await self.middleware.call('ssh.bindiface_choices') invalid_ifaces = list(filter(lambda x: x not in iface_choices, new['bindiface'])) if invalid_ifaces: verrors.add( 'ssh_update.bindiface', f'The following interfaces are not valid: {", ".join(invalid_ifaces)}', ) verrors.check() await self._update_service(old, new) keyfile = "/usr/local/etc/ssh/ssh_host_ecdsa_key.pub" if os.path.exists(keyfile): with open(keyfile, "rb") as f: pubkey = f.read().strip().split(None, 3)[1] decoded_key = base64.b64decode(pubkey) key_digest = hashlib.sha256(decoded_key).digest() ssh_fingerprint = (b"SHA256:" + base64.b64encode(key_digest).replace(b"=", b"")).decode("utf-8") syslog.openlog(logoption=syslog.LOG_PID, facility=syslog.LOG_USER) syslog.syslog(syslog.LOG_ERR, 'ECDSA Fingerprint of the SSH KEY: ' + ssh_fingerprint) syslog.closelog() return new
def restart_omi_if_crashed(omi_installed, mdsd): """ Restart OMI if it crashed. Called from the main monitoring loop. :param omi_installed: bool indicating whether OMI was installed at the previous iteration. :param mdsd: Python Process object for the mdsd process, because it might need to be signaled. :return: bool indicating whether OMI was installed at this iteration (from this call) """ omicli_path = "/opt/omi/bin/omicli" omicli_noop_query_cmd = omicli_path + " noop" omi_was_installed = omi_installed # Remember the OMI install status from the last iteration omi_installed = os.path.isfile(omicli_path) if omi_was_installed and not omi_installed: hutil.log("OMI is uninstalled. This must have been intentional and externally done. " "Will no longer check if OMI is up and running.") omi_reinstalled = not omi_was_installed and omi_installed if omi_reinstalled: hutil.log("OMI is reinstalled. Will resume checking if OMI is up and running.") should_restart_omi = False if omi_installed: cmd_exit_status, cmd_output = RunGetOutput(cmd=omicli_noop_query_cmd, should_log=False) should_restart_omi = cmd_exit_status is not 0 if should_restart_omi: hutil.error("OMI noop query failed. Output: " + cmd_output + ". OMI crash suspected. " "Restarting OMI and sending SIGHUP to mdsd after 5 seconds.") omi_restart_msg = RunGetOutput("/opt/omi/bin/service_control restart")[1] hutil.log("OMI restart result: " + omi_restart_msg) time.sleep(5) # mdsd needs to be signaled if OMI was restarted or reinstalled because mdsd used to give up connecting to OMI # if it fails first time, and never retried until signaled. mdsd was fixed to retry now, but it's still # limited (stops retrying beyond 30 minutes or so) and backoff-ed exponentially # so it's still better to signal anyway. should_signal_mdsd = should_restart_omi or omi_reinstalled if should_signal_mdsd: omi_up_and_running = RunGetOutput(omicli_noop_query_cmd)[0] is 0 if omi_up_and_running: mdsd.send_signal(signal.SIGHUP) hutil.log("SIGHUP sent to mdsd") else: # OMI restarted but not staying up... log_msg = "OMI restarted but not staying up. Will be restarted in the next iteration." hutil.error(log_msg) # Also log this issue on syslog as well syslog.openlog('diagnostic.py', syslog.LOG_PID, syslog.LOG_DAEMON) # syslog.openlog(ident, logoption, facility) -- not taking kw args in Python 2.6 syslog.syslog(syslog.LOG_ALERT, log_msg) # syslog.syslog(priority, message) -- not taking kw args syslog.closelog() return omi_installed
def main(args): syslog.openlog() #Get random message, PID, hostname and application name to concatenate them into the string_message random_message = get_generated_message_and_send_to_journal() process_id = os.getpid() hostname = socket.gethostname() name_of_application = get_application_name() journal_priority_no = get_journal_priority(random_message) journal_total_microsec = get_journal_microseconds(random_message) string_message = journal_priority_no + " " + str( hostname) + " " + name_of_application + "[" + str( process_id) + "]" + ": " + random_message variable_log = "" message_exists_in_syslog = 0 microseconds_difference_acceptable = False time.sleep(2) #testlog = open_readonly(LOG_NAME) with open(LOG_NAME, "r") as testlog: for line in testlog: if string_message in line: message_exists_in_syslog += 1 newline = line.split(" ") variable_log = newline[2] #the datetime is stripped according to the following format,in order to get hour,minute,seconds and convert them to microseconds. syslog_split_time = datetime.datetime.strptime( variable_log, '%H:%M:%S.%f') syslog_hours = syslog_split_time.hour syslog_minutes = syslog_split_time.minute syslog_seconds = syslog_split_time.second syslog_microseconds = syslog_split_time.microsecond syslog_total_microseconds = 60 * 60 * 1000000 * syslog_hours + 60 * 1000000 * syslog_minutes + 1000000 * syslog_seconds + syslog_microseconds total_difference_in_microseconds = syslog_total_microseconds - journal_total_microsec print "Total difference in microseconds between journal timestamp and syslog timestamp is: " + str( total_difference_in_microseconds) #see the documentation on robot test case, for why this amount of difference in microseconds is needed if total_difference_in_microseconds < 350: print "times are almost identical, journal log has passed to syslog" microseconds_difference_acceptable = True else: print "times are different, some error occured during journal writing to syslog" sys.exit(3) testlog.close() syslog.closelog() if message_exists_in_syslog == 1 and microseconds_difference_acceptable: print "string message was found in syslog" sys.exit(0) elif message_exists_in_syslog == 0: print "string_message was not found in any line of the syslog file" sys.exit(1) elif message_exists_in_syslog >= 2: print "duplicate entries of string message were found inside syslog" sys.exit(2)
def main(): try: signal.signal(signal.SIGINT, control_signal) signal.signal(signal.SIGTERM, control_signal) # Para comprobacion de excepciones ver sys.exc_info(). # Comprobar si syslog esta operativo. if (subprocess.check_output( "ps -ea | grep -i syslogd | grep -v grep | wc -l", stderr=subprocess.STDOUT, shell=True)) != b'1\n': raise (SyslogNotRunning) if (len(sys.argv)) == 1: configValues = parseArgs("DEFAULT") logaction = syslog_entry(configValues["delay"], configValues["facility"], configValues["priority"], uuid.uuid4(), configValues["type"]) logaction.printConfig() logaction.start() else: for argumentStr in sys.argv[1:(len(sys.argv))]: configValues = parseArgs(argumentStr) logaction = syslog_entry(configValues["delay"], configValues["facility"], configValues["priority"], uuid.uuid4(), configValues["type"]) logaction.printConfig() logaction.start() while True: time.sleep(0.5) except ExitProgram: print("Finishing logging operations.......") for loggerThread in threading.enumerate(): if loggerThread.getName() == "MainThread": continue loggerThread.close_flag.set() loggerThread.join() except SyslogNotRunning: print( "Syslog daemon is not running. Start syslog service before using syslog_generator." ) sys.exit(2) print("Closing main program.") syslog.closelog() sys.exit(0)
def cleanup(co): """Cleanup routine.""" while co['pins']: pin_obj = co['pins'].pop() pin_obj.close() while co['signals']: s, h = co['signals'].pop() signal(s, h) if co['syslog']: syslog.closelog() co['syslog'] = False return
def _setfileobject(cls, fileobject, close=True): """Redirect log output to an opened file pointer.""" cls._initlogger() if (cls._LOGFILE.fileno() != 1) and close: cls._LOGFILE.close() cls._LOGFILE = fileobject cls._logwrite = cls._logfile # clear other logging options: if cls._SYSLOG: cls._SYSLOG = None syslog.closelog() if cls._JOURNALLOG: cls._JOURNALLOG = False
def log_cef(message_name, message_description, items=[]): FACILITY = syslog.LOG_LOCAL4 syslog.openlog(PROG_NAME, 0, FACILITY) label_string = '' for row in items: for key, value in row.items(): label_string = label_string.join("%s=%s " % (key, value)) cefmsg = 'CEF:0|Mozilla|%s|1.0|%s|%s|5|%s dhost=%s' % ( PROG_NAME, message_name, message_description, label_string, os.uname()[1]) syslog.syslog(syslog.LOG_INFO, cefmsg) syslog.closelog()
def _log(priority, msg, args, verbose=True): tag = { syslog.LOG_INFO: "INFO", syslog.LOG_WARNING: "WARNING", syslog.LOG_ERR: "ERROR", syslog.LOG_DEBUG: "DEBUG", } msg = msg % args if args else msg if verbose: sys.stderr.write("{}: {}\n".format(tag[priority], msg)) syslog.openlog(facility=syslog.LOG_SYSLOG) syslog.syslog(priority, msg) syslog.closelog()
def producerlog(self, repo, action, *args): """Write to the producer syslog facility.""" ident = self.config('replicationproducer', 'syslogident', 'vcsreplicator') facility = self.config('replicationproducer', 'syslogfacility', 'LOG_LOCAL2') facility = getattr(syslog, facility) syslog.openlog(ident, 0, facility) if not isinstance(repo, str): repo = repo.replicationwireprotopath pre = '%s %s %s' % (os.environ.get('USER', '<unknown>'), repo, action) syslog.syslog(syslog.LOG_NOTICE, '%s %s' % (pre, ' '.join(args))) syslog.closelog()
def log_cef(message_name, message_description, items=None): facility = syslog.LOG_LOCAL4 syslog.openlog(PROG_NAME, 0, facility) label_string = '' if items is not None: for row in items: for key, value in list(row.items()): label_string = label_string.join("%s=%s " % (key, value)) cefmsg = 'CEF:0|Mozilla|%s|1.0|%s|%s|5|%s dhost=%s' % ( PROG_NAME, message_name, message_description, label_string, os.uname()[1]) # noqa syslog.syslog(syslog.LOG_INFO, cefmsg) syslog.closelog()
def write_error(self, text, *args): """ Writes an error to the log. Args: text (str): Text to write to the log. args (tuple) : Arguments to use when formatting the text. """ if not self._error_level_enabled: return message = text.format(*args) openlog(ident=self.__ident, facility=self.__facility) syslog(LOG_ERR, message) closelog()
def _process_message(self): try: msg = self._deque.popleft() tag = msg['tag'] facility = msg['facility'] severity = msg['severity'] syslog.openlog(tag, 0, getattr(syslog, facility)) syslog.syslog(getattr(syslog, severity), self._shrink(msg['payload'])) syslog.closelog() return True except IndexError: time.sleep(0.1) return False
def main(): # define the available arguments/parameters that a user can pass to # the module module_args = dict(ident=dict(type='str', default='ansible_syslogger'), msg=dict(type='str', required=True), priority=dict(type='str', required=False, choices=[ "emerg", "alert", "crit", "err", "warning", "notice", "info", "debug" ], default='info'), facility=dict(type='str', required=False, choices=[ "kern", "user", "mail", "daemon", "auth", "lpr", "news", "uucp", "cron", "syslog", "local0", "local1", "local2", "local3", "local4", "local5", "local6", "local7" ], default='daemon'), log_pid=dict(type='bool', required=False, default=False)) module = AnsibleModule(argument_spec=module_args, ) result = dict(changed=False, ident=module.params['ident'], priority=module.params['priority'], facility=module.params['facility'], log_pid=module.params['log_pid'], msg=module.params['msg']) # do the logging try: syslog.openlog(module.params['ident'], syslog.LOG_PID if module.params['log_pid'] else 0, get_facility(module.params['facility'])) syslog.syslog(get_priority(module.params['priority']), module.params['msg']) syslog.closelog() result['changed'] = True except Exception as exc: module.fail_json(error='Failed to write to syslog %s' % to_native(exc), exception=traceback.format_exc(), **result) module.exit_json(**result)
def auth_log(host, user, passwd): """Send errors to default auth log""" today = datetime.date.today() time = datetime.datetime.today() f = open('/var/log/telnet-' + str(today) + '.csv', 'ab') csvwriter = csv.writer(f) syslog.openlog(facility=syslog.LOG_AUTH) syslog.syslog("Telnet Attack Logged:(" + str(host) + ":" + str(user) + ":" + str(passwd) + ")") syslog.closelog() attempt = [host, user, passwd, time] if (host != 'localhost'): csvwriter.writerow(attempt) f.close()