Add a routine to format error messages with an errno-based message at the end.

[libpcap] / pcap-snit.c

diff --git a/pcap-snit.c b/pcap-snit.c
index 24368f6e0703e3c128bc0922ee62272e01d3c09f..9da8573d96fd55cd0c3af33c07a7ae8d58f8faeb 100644 (file)
--- a/pcap-snit.c
+++ b/pcap-snit.c
@@ -130,8 +130,8 @@ pcap_read_snit(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                if (cc < 0) {
                        if (errno == EWOULDBLOCK)
                                return (0);
-                       pcap_snprintf(p->errbuf, sizeof(p->errbuf), "pcap_read: %s",
-                               pcap_strerror(errno));
+                       pcap_fmt_errmsg_for_errno(p->errbuf, sizeof(p->errbuf),
+                           errno, "pcap_read");
                        return (-1);
                }
                bp = (u_char *)p->buffer;
@@ -223,8 +223,8 @@ pcap_inject_snit(pcap_t *p, const void *buf, size_t size)
        data.len = size;
        ret = putmsg(p->fd, &ctl, &data);
        if (ret == -1) {
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
-                   pcap_strerror(errno));
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "send");
                return (-1);
        }
        return (ret);
@@ -247,8 +247,8 @@ nit_setflags(pcap_t *p)
                si.ic_len = sizeof(zero);
                si.ic_dp = (char *)&zero;
                if (ioctl(p->fd, I_STR, (char *)&si) < 0) {
-                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSCHUNK: %s",
-                           pcap_strerror(errno));
+                       pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                           errno, "NIOCSCHUNK");
                        return (-1);
                }
        }
@@ -260,8 +260,8 @@ nit_setflags(pcap_t *p)
                si.ic_len = sizeof(timeout);
                si.ic_dp = (char *)&timeout;
                if (ioctl(p->fd, I_STR, (char *)&si) < 0) {
-                       pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSTIME: %s",
-                           pcap_strerror(errno));
+                       pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                           errno, "NIOCSTIME");
                        return (-1);
                }
        }
@@ -272,8 +272,8 @@ nit_setflags(pcap_t *p)
        si.ic_len = sizeof(flags);
        si.ic_dp = (char *)&flags;
        if (ioctl(p->fd, I_STR, (char *)&si) < 0) {
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSFLAGS: %s",
-                   pcap_strerror(errno));
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "NIOCSFLAGS");
                return (-1);
        }
        return (0);
@@ -287,6 +287,7 @@ pcap_activate_snit(pcap_t *p)
        int chunksize = CHUNKSIZE;
        int fd;
        static const char dev[] = "/dev/nit";
+       int err;
 
        if (p->opt.rfmon) {
                /*
@@ -331,20 +332,26 @@ pcap_activate_snit(pcap_t *p)
        if (fd < 0 && errno == EACCES)
                p->fd = fd = open(dev, O_RDONLY);
        if (fd < 0) {
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "%s: %s", dev,
-                   pcap_strerror(errno));
+               if (errno == EACCES)
+                       err = PCAP_ERROR_PERM_DENIED;
+               else
+                       err = PCAP_ERROR;
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "%s", dev);
                goto bad;
        }
 
        /* arrange to get discrete messages from the STREAM and use NIT_BUF */
        if (ioctl(fd, I_SRDOPT, (char *)RMSGD) < 0) {
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "I_SRDOPT: %s",
-                   pcap_strerror(errno));
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "I_SRDOPT");
+               err = PCAP_ERROR;
                goto bad;
        }
        if (ioctl(fd, I_PUSH, "nbuf") < 0) {
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "push nbuf: %s",
-                   pcap_strerror(errno));
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "push nbuf");
+               err = PCAP_ERROR;
                goto bad;
        }
        /* set the chunksize */
@@ -353,8 +360,9 @@ pcap_activate_snit(pcap_t *p)
        si.ic_len = sizeof(chunksize);
        si.ic_dp = (char *)&chunksize;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSCHUNK: %s",
-                   pcap_strerror(errno));
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "NIOCSCHUNK");
+               err = PCAP_ERROR;
                goto bad;
        }
 
@@ -370,8 +378,9 @@ pcap_activate_snit(pcap_t *p)
                 * Is there one that means "that device doesn't support
                 * STREAMS NIT"?
                 */
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCBIND: %s: %s",
-                       ifr.ifr_name, pcap_strerror(errno));
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "NIOCBIND: %s", ifr.ifr_name);
+               err = PCAP_ERROR;
                goto bad;
        }
 
@@ -380,12 +389,15 @@ pcap_activate_snit(pcap_t *p)
        si.ic_len = sizeof(p->snapshot);
        si.ic_dp = (char *)&p->snapshot;
        if (ioctl(fd, I_STR, (char *)&si) < 0) {
-               pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "NIOCSSNAP: %s",
-                   pcap_strerror(errno));
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "NIOCSSNAP");
+               err = PCAP_ERROR;
                goto bad;
        }
-       if (nit_setflags(p) < 0)
+       if (nit_setflags(p) < 0) {
+               err = PCAP_ERROR;
                goto bad;
+       }
 
        (void)ioctl(fd, I_FLUSH, (char *)FLUSHR);
        /*
@@ -396,7 +408,9 @@ pcap_activate_snit(pcap_t *p)
        p->bufsize = BUFSPACE;
        p->buffer = malloc(p->bufsize);
        if (p->buffer == NULL) {
-               strlcpy(p->errbuf, pcap_strerror(errno), PCAP_ERRBUF_SIZE);
+               pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,
+                   errno, "malloc");
+               err = PCAP_ERROR;
                goto bad;
        }
 
@@ -438,7 +452,7 @@ pcap_activate_snit(pcap_t *p)
        return (0);
  bad:
        pcap_cleanup_live_common(p);
-       return (PCAP_ERROR);
+       return (err);
 }
 
 pcap_t *