work on making log.c similar in all daemons: · jcs.org/openbsd-src@fcdf914

+3 -3

usr.sbin/eigrpd/Makefile

··· 1 - # $OpenBSD: Makefile,v 1.1 2015/10/02 04:26:47 renato Exp $ 1 + # $OpenBSD: Makefile,v 1.2 2016/09/02 17:59:58 benno Exp $ 2 2 3 3 PROG= eigrpd 4 4 SRCS= control.c eigrpd.c eigrpe.c hello.c in_cksum.c interface.c \ 5 - kroute.c log.c neighbor.c packet.c parse.y printconf.c query.c \ 6 - rde.c rde_dual.c reply.c rtp.c tlv.c update.c util.c 5 + kroute.c log.c logmsg.c neighbor.c packet.c parse.y printconf.c \ 6 + query.c rde.c rde_dual.c reply.c rtp.c tlv.c update.c util.c 7 7 8 8 MAN= eigrpd.8 eigrpd.conf.5 9 9

+2 -1

usr.sbin/eigrpd/eigrpd.c

··· 1 - /* $OpenBSD: eigrpd.c,v 1.20 2016/09/02 16:44:33 renato Exp $ */ 1 + /* $OpenBSD: eigrpd.c,v 1.21 2016/09/02 17:59:58 benno Exp $ */ 2 2 3 3 /* 4 4 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org> ··· 111 111 112 112 conffile = CONF_FILE; 113 113 eigrpd_process = PROC_MAIN; 114 + log_procname = log_procnames[eigrpd_process]; 114 115 sockname = EIGRPD_SOCKET; 115 116 116 117 log_init(1); /* log to stderr until daemonized */

+20 -1

usr.sbin/eigrpd/eigrpd.h

··· 1 - /* $OpenBSD: eigrpd.h,v 1.21 2016/09/02 16:46:29 renato Exp $ */ 1 + /* $OpenBSD: eigrpd.h,v 1.22 2016/09/02 17:59:58 benno Exp $ */ 2 2 3 3 /* 4 4 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org> ··· 60 60 #define F_CTL_EXTERNAL 0x0200 /* only used by eigrpctl */ 61 61 #define F_CTL_ACTIVE 0x0400 62 62 #define F_CTL_ALLLINKS 0x0800 63 + 64 + static const char * const log_procnames[] = { 65 + "parent", 66 + "eigrpe", 67 + "rde" 68 + }; 63 69 64 70 struct imsgev { 65 71 struct imsgbuf ibuf; ··· 501 507 502 508 /* printconf.c */ 503 509 void print_config(struct eigrpd_conf *); 510 + 511 + /* logmsg.c */ 512 + const char *log_in6addr(const struct in6_addr *); 513 + const char *log_in6addr_scope(const struct in6_addr *, unsigned int); 514 + const char *log_sockaddr(void *); 515 + const char *log_addr(int, union eigrpd_addr *); 516 + const char *log_prefix(struct rt_node *); 517 + const char *log_route_origin(int, struct rde_nbr *); 518 + const char *opcode_name(uint8_t); 519 + const char *af_name(int); 520 + const char *if_type_name(enum iface_type); 521 + const char *dual_state_name(int); 522 + const char *ext_proto_name(int); 504 523 505 524 #endif /* _EIGRPD_H_ */

+2 -1

usr.sbin/eigrpd/eigrpe.c

··· 1 - /* $OpenBSD: eigrpe.c,v 1.33 2016/09/02 16:46:29 renato Exp $ */ 1 + /* $OpenBSD: eigrpe.c,v 1.34 2016/09/02 17:59:58 benno Exp $ */ 2 2 3 3 /* 4 4 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org> ··· 126 126 127 127 setproctitle("eigrp engine"); 128 128 eigrpd_process = PROC_EIGRP_ENGINE; 129 + log_procname = log_procnames[eigrpd_process]; 129 130 130 131 if (setgroups(1, &pw->pw_gid) || 131 132 setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||

+10 -210

usr.sbin/eigrpd/log.c

··· 1 - /* $OpenBSD: log.c,v 1.6 2016/09/02 16:46:29 renato Exp $ */ 1 + /* $OpenBSD: log.c,v 1.7 2016/09/02 17:59:58 benno Exp $ */ 2 2 3 3 /* 4 4 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> ··· 26 26 #include <stdlib.h> 27 27 #include <string.h> 28 28 #include <syslog.h> 29 + #include <time.h> 29 30 #include <unistd.h> 31 + #include <arpa/inet.h> 32 + #include <netdb.h> 30 33 31 34 #include "eigrpd.h" 32 - #include "rde.h" 33 35 #include "log.h" 34 36 35 - static const char * const procnames[] = { 36 - "parent", 37 - "eigrpe", 38 - "rde" 39 - }; 40 - 41 - int debug; 42 - int verbose; 37 + int debug; 38 + int verbose; 39 + const char *log_procname; 43 40 44 41 void 45 42 log_init(int n_debug) ··· 149 146 fatal(const char *emsg) 150 147 { 151 148 if (emsg == NULL) 152 - logit(LOG_CRIT, "fatal in %s: %s", procnames[eigrpd_process], 149 + logit(LOG_CRIT, "fatal in %s: %s", log_procnames[eigrpd_process], 153 150 strerror(errno)); 154 151 else 155 152 if (errno) 156 153 logit(LOG_CRIT, "fatal in %s: %s: %s", 157 - procnames[eigrpd_process], emsg, strerror(errno)); 154 + log_procnames[eigrpd_process], emsg, strerror(errno)); 158 155 else 159 156 logit(LOG_CRIT, "fatal in %s: %s", 160 - procnames[eigrpd_process], emsg); 157 + log_procnames[eigrpd_process], emsg); 161 158 162 159 exit(1); 163 160 } ··· 168 165 errno = 0; 169 166 fatal(emsg); 170 167 } 171 - 172 - #define NUM_LOGS 4 173 - const char * 174 - log_sockaddr(void *vp) 175 - { 176 - static char buf[NUM_LOGS][NI_MAXHOST]; 177 - static int round = 0; 178 - struct sockaddr *sa = vp; 179 - 180 - round = (round + 1) % NUM_LOGS; 181 - 182 - if (getnameinfo(sa, sa->sa_len, buf[round], NI_MAXHOST, NULL, 0, 183 - NI_NUMERICHOST)) 184 - return ("(unknown)"); 185 - else 186 - return (buf[round]); 187 - } 188 - 189 - const char * 190 - log_in6addr(const struct in6_addr *addr) 191 - { 192 - struct sockaddr_in6 sa_in6; 193 - 194 - memset(&sa_in6, 0, sizeof(sa_in6)); 195 - sa_in6.sin6_len = sizeof(sa_in6); 196 - sa_in6.sin6_family = AF_INET6; 197 - sa_in6.sin6_addr = *addr; 198 - 199 - recoverscope(&sa_in6); 200 - 201 - return (log_sockaddr(&sa_in6)); 202 - } 203 - 204 - const char * 205 - log_in6addr_scope(const struct in6_addr *addr, unsigned int ifindex) 206 - { 207 - struct sockaddr_in6 sa_in6; 208 - 209 - memset(&sa_in6, 0, sizeof(sa_in6)); 210 - sa_in6.sin6_len = sizeof(sa_in6); 211 - sa_in6.sin6_family = AF_INET6; 212 - sa_in6.sin6_addr = *addr; 213 - 214 - addscope(&sa_in6, ifindex); 215 - 216 - return (log_sockaddr(&sa_in6)); 217 - } 218 - 219 - const char * 220 - log_addr(int af, union eigrpd_addr *addr) 221 - { 222 - static char buf[NUM_LOGS][INET6_ADDRSTRLEN]; 223 - static int round = 0; 224 - 225 - switch (af) { 226 - case AF_INET: 227 - round = (round + 1) % NUM_LOGS; 228 - if (inet_ntop(AF_INET, &addr->v4, buf[round], 229 - sizeof(buf[round])) == NULL) 230 - return ("???"); 231 - return (buf[round]); 232 - case AF_INET6: 233 - return (log_in6addr(&addr->v6)); 234 - default: 235 - break; 236 - } 237 - 238 - return ("???"); 239 - } 240 - 241 - const char * 242 - log_prefix(struct rt_node *rn) 243 - { 244 - static char buf[64]; 245 - 246 - if (snprintf(buf, sizeof(buf), "%s/%u", log_addr(rn->eigrp->af, 247 - &rn->prefix), rn->prefixlen) == -1) 248 - return ("???"); 249 - 250 - return (buf); 251 - } 252 - 253 - const char * 254 - log_route_origin(int af, struct rde_nbr *nbr) 255 - { 256 - if (nbr->flags & F_RDE_NBR_SELF) { 257 - if (nbr->flags & F_RDE_NBR_REDIST) 258 - return ("redistribute"); 259 - if (nbr->flags & F_RDE_NBR_SUMMARY) 260 - return ("summary"); 261 - else 262 - return ("connected"); 263 - } 264 - 265 - return (log_addr(af, &nbr->addr)); 266 - } 267 - 268 - const char * 269 - opcode_name(uint8_t opcode) 270 - { 271 - switch (opcode) { 272 - case EIGRP_OPC_UPDATE: 273 - return ("UPDATE"); 274 - case EIGRP_OPC_REQUEST: 275 - return ("REQUEST"); 276 - case EIGRP_OPC_QUERY: 277 - return ("QUERY"); 278 - case EIGRP_OPC_REPLY: 279 - return ("REPLY"); 280 - case EIGRP_OPC_HELLO: 281 - return ("HELLO"); 282 - case EIGRP_OPC_PROBE: 283 - return ("PROBE"); 284 - case EIGRP_OPC_SIAQUERY: 285 - return ("SIAQUERY"); 286 - case EIGRP_OPC_SIAREPLY: 287 - return ("SIAREPLY"); 288 - default: 289 - return ("UNKNOWN"); 290 - } 291 - } 292 - 293 - const char * 294 - af_name(int af) 295 - { 296 - switch (af) { 297 - case AF_INET: 298 - return ("ipv4"); 299 - case AF_INET6: 300 - return ("ipv6"); 301 - default: 302 - return ("UNKNOWN"); 303 - } 304 - } 305 - 306 - const char * 307 - if_type_name(enum iface_type type) 308 - { 309 - switch (type) { 310 - case IF_TYPE_POINTOPOINT: 311 - return ("POINTOPOINT"); 312 - case IF_TYPE_BROADCAST: 313 - return ("BROADCAST"); 314 - default: 315 - return ("UNKNOWN"); 316 - } 317 - } 318 - 319 - const char * 320 - dual_state_name(int state) 321 - { 322 - switch (state) { 323 - case DUAL_STA_PASSIVE: 324 - return ("PASSIVE"); 325 - case DUAL_STA_ACTIVE0: 326 - return ("ACTIVE(Oij=0)"); 327 - case DUAL_STA_ACTIVE1: 328 - return ("ACTIVE(Oij=1)"); 329 - case DUAL_STA_ACTIVE2: 330 - return ("ACTIVE(Oij=2)"); 331 - case DUAL_STA_ACTIVE3: 332 - return ("ACTIVE(Oij=3)"); 333 - default: 334 - return ("UNKNOWN"); 335 - } 336 - } 337 - 338 - const char * 339 - ext_proto_name(int proto) 340 - { 341 - switch (proto) { 342 - case EIGRP_EXT_PROTO_IGRP: 343 - return ("IGRP"); 344 - case EIGRP_EXT_PROTO_EIGRP: 345 - return ("EIGRP"); 346 - case EIGRP_EXT_PROTO_STATIC: 347 - return ("Static"); 348 - case EIGRP_EXT_PROTO_RIP: 349 - return ("RIP"); 350 - case EIGRP_EXT_PROTO_HELLO: 351 - return ("HELLO"); 352 - case EIGRP_EXT_PROTO_OSPF: 353 - return ("OSPF"); 354 - case EIGRP_EXT_PROTO_ISIS: 355 - return ("ISIS"); 356 - case EIGRP_EXT_PROTO_EGP: 357 - return ("EGP"); 358 - case EIGRP_EXT_PROTO_BGP: 359 - return ("BGP"); 360 - case EIGRP_EXT_PROTO_IDRP: 361 - return ("IDRP"); 362 - case EIGRP_EXT_PROTO_CONN: 363 - return ("Connected"); 364 - default: 365 - return ("UNKNOWN"); 366 - } 367 - }

+25 -33

usr.sbin/eigrpd/log.h

··· 1 - /* $OpenBSD: log.h,v 1.4 2016/09/02 16:44:33 renato Exp $ */ 1 + /* $OpenBSD: log.h,v 1.5 2016/09/02 17:59:58 benno Exp $ */ 2 2 3 3 /* 4 4 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> ··· 16 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 17 */ 18 18 19 - #ifndef _LOG_H_ 20 - #define _LOG_H_ 19 + #ifndef LOG_H 20 + #define LOG_H 21 21 22 22 #include <stdarg.h> 23 + #include <sys/cdefs.h> 23 24 24 - void log_init(int); 25 - void log_verbose(int); 26 - void logit(int, const char *, ...) 27 - __attribute__((__format__ (printf, 2, 3))); 28 - void vlog(int, const char *, va_list) 29 - __attribute__((__format__ (printf, 2, 0))); 30 - void log_warn(const char *, ...) 31 - __attribute__((__format__ (printf, 1, 2))); 32 - void log_warnx(const char *, ...) 33 - __attribute__((__format__ (printf, 1, 2))); 34 - void log_info(const char *, ...) 35 - __attribute__((__format__ (printf, 1, 2))); 36 - void log_debug(const char *, ...) 37 - __attribute__((__format__ (printf, 1, 2))); 38 - void fatal(const char *) __dead 39 - __attribute__((__format__ (printf, 1, 0))); 40 - void fatalx(const char *) __dead 41 - __attribute__((__format__ (printf, 1, 0))); 42 - const char *log_in6addr(const struct in6_addr *); 43 - const char *log_in6addr_scope(const struct in6_addr *, unsigned int); 44 - const char *log_sockaddr(void *); 45 - const char *log_addr(int, union eigrpd_addr *); 46 - const char *log_prefix(struct rt_node *); 47 - const char *log_route_origin(int, struct rde_nbr *); 48 - const char *opcode_name(uint8_t); 49 - const char *af_name(int); 50 - const char *if_type_name(enum iface_type); 51 - const char *dual_state_name(int); 52 - const char *ext_proto_name(int); 25 + extern const char *log_procname; 26 + 27 + void log_init(int); 28 + void log_verbose(int); 29 + void logit(int, const char *, ...) 30 + __attribute__((__format__ (printf, 2, 3))); 31 + void vlog(int, const char *, va_list) 32 + __attribute__((__format__ (printf, 2, 0))); 33 + void log_warn(const char *, ...) 34 + __attribute__((__format__ (printf, 1, 2))); 35 + void log_warnx(const char *, ...) 36 + __attribute__((__format__ (printf, 1, 2))); 37 + void log_info(const char *, ...) 38 + __attribute__((__format__ (printf, 1, 2))); 39 + void log_debug(const char *, ...) 40 + __attribute__((__format__ (printf, 1, 2))); 41 + void fatal(const char *) __dead 42 + __attribute__((__format__ (printf, 1, 0))); 43 + void fatalx(const char *) __dead 44 + __attribute__((__format__ (printf, 1, 0))); 53 45 54 - #endif /* _LOG_H_ */ 46 + #endif /* LOG_H */

+228

usr.sbin/eigrpd/logmsg.c

··· 1 + /* $OpenBSD: logmsg.c,v 1.1 2016/09/02 17:59:58 benno Exp $ */ 2 + 3 + /* 4 + * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org> 5 + * 6 + * Permission to use, copy, modify, and distribute this software for any 7 + * purpose with or without fee is hereby granted, provided that the above 8 + * copyright notice and this permission notice appear in all copies. 9 + * 10 + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 + */ 18 + 19 + #include <errno.h> 20 + #include <stdarg.h> 21 + #include <stdio.h> 22 + #include <stdlib.h> 23 + #include <string.h> 24 + #include <syslog.h> 25 + #include <unistd.h> 26 + #include <arpa/inet.h> 27 + #include <netdb.h> 28 + 29 + #include "eigrpd.h" 30 + #include "rde.h" 31 + #include "log.h" 32 + 33 + #define NUM_LOGS 4 34 + const char * 35 + log_sockaddr(void *vp) 36 + { 37 + static char buf[NUM_LOGS][NI_MAXHOST]; 38 + static int round = 0; 39 + struct sockaddr *sa = vp; 40 + 41 + round = (round + 1) % NUM_LOGS; 42 + 43 + if (getnameinfo(sa, sa->sa_len, buf[round], NI_MAXHOST, NULL, 0, 44 + NI_NUMERICHOST)) 45 + return ("(unknown)"); 46 + else 47 + return (buf[round]); 48 + } 49 + 50 + const char * 51 + log_in6addr(const struct in6_addr *addr) 52 + { 53 + struct sockaddr_in6 sa_in6; 54 + 55 + memset(&sa_in6, 0, sizeof(sa_in6)); 56 + sa_in6.sin6_len = sizeof(sa_in6); 57 + sa_in6.sin6_family = AF_INET6; 58 + sa_in6.sin6_addr = *addr; 59 + 60 + recoverscope(&sa_in6); 61 + 62 + return (log_sockaddr(&sa_in6)); 63 + } 64 + 65 + const char * 66 + log_in6addr_scope(const struct in6_addr *addr, unsigned int ifindex) 67 + { 68 + struct sockaddr_in6 sa_in6; 69 + 70 + memset(&sa_in6, 0, sizeof(sa_in6)); 71 + sa_in6.sin6_len = sizeof(sa_in6); 72 + sa_in6.sin6_family = AF_INET6; 73 + sa_in6.sin6_addr = *addr; 74 + 75 + addscope(&sa_in6, ifindex); 76 + 77 + return (log_sockaddr(&sa_in6)); 78 + } 79 + 80 + const char * 81 + log_addr(int af, union eigrpd_addr *addr) 82 + { 83 + static char buf[NUM_LOGS][INET6_ADDRSTRLEN]; 84 + static int round = 0; 85 + 86 + switch (af) { 87 + case AF_INET: 88 + round = (round + 1) % NUM_LOGS; 89 + if (inet_ntop(AF_INET, &addr->v4, buf[round], 90 + sizeof(buf[round])) == NULL) 91 + return ("???"); 92 + return (buf[round]); 93 + case AF_INET6: 94 + return (log_in6addr(&addr->v6)); 95 + default: 96 + break; 97 + } 98 + 99 + return ("???"); 100 + } 101 + 102 + const char * 103 + log_prefix(struct rt_node *rn) 104 + { 105 + static char buf[64]; 106 + 107 + if (snprintf(buf, sizeof(buf), "%s/%u", log_addr(rn->eigrp->af, 108 + &rn->prefix), rn->prefixlen) == -1) 109 + return ("???"); 110 + 111 + return (buf); 112 + } 113 + 114 + const char * 115 + log_route_origin(int af, struct rde_nbr *nbr) 116 + { 117 + if (nbr->flags & F_RDE_NBR_SELF) { 118 + if (nbr->flags & F_RDE_NBR_REDIST) 119 + return ("redistribute"); 120 + if (nbr->flags & F_RDE_NBR_SUMMARY) 121 + return ("summary"); 122 + else 123 + return ("connected"); 124 + } 125 + 126 + return (log_addr(af, &nbr->addr)); 127 + } 128 + 129 + const char * 130 + opcode_name(uint8_t opcode) 131 + { 132 + switch (opcode) { 133 + case EIGRP_OPC_UPDATE: 134 + return ("UPDATE"); 135 + case EIGRP_OPC_REQUEST: 136 + return ("REQUEST"); 137 + case EIGRP_OPC_QUERY: 138 + return ("QUERY"); 139 + case EIGRP_OPC_REPLY: 140 + return ("REPLY"); 141 + case EIGRP_OPC_HELLO: 142 + return ("HELLO"); 143 + case EIGRP_OPC_PROBE: 144 + return ("PROBE"); 145 + case EIGRP_OPC_SIAQUERY: 146 + return ("SIAQUERY"); 147 + case EIGRP_OPC_SIAREPLY: 148 + return ("SIAREPLY"); 149 + default: 150 + return ("UNKNOWN"); 151 + } 152 + } 153 + 154 + const char * 155 + af_name(int af) 156 + { 157 + switch (af) { 158 + case AF_INET: 159 + return ("ipv4"); 160 + case AF_INET6: 161 + return ("ipv6"); 162 + default: 163 + return ("UNKNOWN"); 164 + } 165 + } 166 + 167 + const char * 168 + if_type_name(enum iface_type type) 169 + { 170 + switch (type) { 171 + case IF_TYPE_POINTOPOINT: 172 + return ("POINTOPOINT"); 173 + case IF_TYPE_BROADCAST: 174 + return ("BROADCAST"); 175 + default: 176 + return ("UNKNOWN"); 177 + } 178 + } 179 + 180 + const char * 181 + dual_state_name(int state) 182 + { 183 + switch (state) { 184 + case DUAL_STA_PASSIVE: 185 + return ("PASSIVE"); 186 + case DUAL_STA_ACTIVE0: 187 + return ("ACTIVE(Oij=0)"); 188 + case DUAL_STA_ACTIVE1: 189 + return ("ACTIVE(Oij=1)"); 190 + case DUAL_STA_ACTIVE2: 191 + return ("ACTIVE(Oij=2)"); 192 + case DUAL_STA_ACTIVE3: 193 + return ("ACTIVE(Oij=3)"); 194 + default: 195 + return ("UNKNOWN"); 196 + } 197 + } 198 + 199 + const char * 200 + ext_proto_name(int proto) 201 + { 202 + switch (proto) { 203 + case EIGRP_EXT_PROTO_IGRP: 204 + return ("IGRP"); 205 + case EIGRP_EXT_PROTO_EIGRP: 206 + return ("EIGRP"); 207 + case EIGRP_EXT_PROTO_STATIC: 208 + return ("Static"); 209 + case EIGRP_EXT_PROTO_RIP: 210 + return ("RIP"); 211 + case EIGRP_EXT_PROTO_HELLO: 212 + return ("HELLO"); 213 + case EIGRP_EXT_PROTO_OSPF: 214 + return ("OSPF"); 215 + case EIGRP_EXT_PROTO_ISIS: 216 + return ("ISIS"); 217 + case EIGRP_EXT_PROTO_EGP: 218 + return ("EGP"); 219 + case EIGRP_EXT_PROTO_BGP: 220 + return ("BGP"); 221 + case EIGRP_EXT_PROTO_IDRP: 222 + return ("IDRP"); 223 + case EIGRP_EXT_PROTO_CONN: 224 + return ("Connected"); 225 + default: 226 + return ("UNKNOWN"); 227 + } 228 + }