ptools/pfiles/pfiles.c

	pfiles.c revision 0d166b18feda26f6f45f5be1c0c8c5e539b90e6c
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <ctype.h>
#include <string.h>
#include <signal.h>
#include <dirent.h>
#include <limits.h>
#include <door.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/mkdev.h>
#include <sys/stropts.h>
#include <sys/timod.h>
#include <sys/un.h>
#include <libproc.h>
#include <netinet/in.h>
#include <netinet/udp.h>
#include <arpa/inet.h>

#define copyflock(dst, src) \
    (dst).l_type = (src).l_type;        \
    (dst).l_whence = (src).l_whence;    \
    (dst).l_start = (src).l_start;      \
    (dst).l_len = (src).l_len;      \
    (dst).l_sysid = (src).l_sysid;      \
    (dst).l_pid = (src).l_pid;

static char *command;
static volatile int interrupt;
static int Fflag;
static boolean_t nflag = B_FALSE;

static  void    intr(int);
static  void    dofcntl(struct ps_prochandle *, int, int, int);
static  void    dosocket(struct ps_prochandle *, int);
static  void    dotli(struct ps_prochandle *, int);
static  void    show_files(struct ps_prochandle *);
static  void    show_fileflags(int);
static  void    show_door(struct ps_prochandle *, int);
static  int getflock(struct ps_prochandle *, int, struct flock *);

int
main(int argc, char **argv)
{
    int retc = 0;
    int opt;
    int errflg = 0;
    struct ps_prochandle *Pr;

    if ((command = strrchr(argv[0], '/')) != NULL)
        command++;
    else
        command = argv[0];

    /* options */
    while ((opt = getopt(argc, argv, "Fn")) != EOF) {
        switch (opt) {
        case 'F':       /* force grabbing (no O_EXCL) */
            Fflag = PGRAB_FORCE;
            break;
        case 'n':
            nflag = B_TRUE;
            break;
        default:
            errflg = 1;
            break;
        }
    }

    argc -= optind;
    argv += optind;

    if (errflg || argc <= 0) {
        (void) fprintf(stderr, "usage:\t%s [-F] pid ...\n",
            command);
        (void) fprintf(stderr,
            "  (report open files of each process)\n");
        (void) fprintf(stderr,
            "  -F: force grabbing of the target process\n");
        exit(2);
    }

    /* catch signals from terminal */
    if (sigset(SIGHUP, SIG_IGN) == SIG_DFL)
        (void) sigset(SIGHUP, intr);
    if (sigset(SIGINT, SIG_IGN) == SIG_DFL)
        (void) sigset(SIGINT, intr);
    if (sigset(SIGQUIT, SIG_IGN) == SIG_DFL)
        (void) sigset(SIGQUIT, intr);
    (void) sigset(SIGPIPE, intr);
    (void) sigset(SIGTERM, intr);

    (void) proc_initstdio();


    while (--argc >= 0 && !interrupt) {
        char *arg;
        psinfo_t psinfo;
        pid_t pid;
        int gret;

        (void) proc_flushstdio();

        /* get the specified pid and the psinfo struct */
        if ((pid = proc_arg_psinfo(arg = *argv++, PR_ARG_PIDS,
            &psinfo, &gret)) == -1) {
            (void) fprintf(stderr, "%s: cannot examine %s: %s\n",
                command, arg, Pgrab_error(gret));
            retc++;
        } else if ((Pr = Pgrab(pid, Fflag, &gret)) != NULL) {
            if (Pcreate_agent(Pr) == 0) {
                proc_unctrl_psinfo(&psinfo);
                (void) printf("%d:\t%.70s\n",
                    (int)pid, psinfo.pr_psargs);
                show_files(Pr);
                Pdestroy_agent(Pr);
            } else {
                (void) fprintf(stderr,
                    "%s: cannot control process %d\n",
                    command, (int)pid);
                retc++;
            }
            Prelease(Pr, 0);
            Pr = NULL;
        } else {
            switch (gret) {
            case G_SYS:
            case G_SELF:
                proc_unctrl_psinfo(&psinfo);
                (void) printf("%d:\t%.70s\n", (int)pid,
                    psinfo.pr_psargs);
                if (gret == G_SYS)
                    (void) printf("  [system process]\n");
                else
                    show_files(NULL);
                break;
            default:
                (void) fprintf(stderr, "%s: %s: %d\n",
                    command, Pgrab_error(gret), (int)pid);
                retc++;
                break;
            }
        }
    }

    (void) proc_finistdio();

    if (interrupt && retc == 0)
        retc++;
    return (retc);
}

/* ARGSUSED */
static void
intr(int sig)
{
    interrupt = 1;
}

/* ------ begin specific code ------ */

static void
show_files(struct ps_prochandle *Pr)
{
    DIR *dirp;
    struct dirent *dentp;
    const char *dev;
    char pname[100];
    char fname[PATH_MAX];
    struct stat64 statb;
    struct rlimit rlim;
    pid_t pid;
    int fd;
    char *s;
    int ret;

    if (pr_getrlimit(Pr, RLIMIT_NOFILE, &rlim) == 0) {
        ulong_t nfd = rlim.rlim_cur;
        if (nfd == RLIM_INFINITY)
            (void) printf(
                "  Current rlimit: unlimited file descriptors\n");
        else
            (void) printf(
                "  Current rlimit: %lu file descriptors\n", nfd);
    }

    /* in case we are doing this to ourself */
    pid = (Pr == NULL)? getpid() : Pstatus(Pr)->pr_pid;

    (void) sprintf(pname, "/proc/%d/fd", (int)pid);
    if ((dirp = opendir(pname)) == NULL) {
        (void) fprintf(stderr, "%s: cannot open directory %s\n",
            command, pname);
        return;
    }

    /* for each open file --- */
    while ((dentp = readdir(dirp)) != NULL && !interrupt) {
        char unknown[12];
        dev_t rdev;

        /* skip '.' and '..' */
        if (!isdigit(dentp->d_name[0]))
            continue;

        fd = atoi(dentp->d_name);
        if (pr_fstat64(Pr, fd, &statb) == -1) {
            s = unknown;
            (void) sprintf(s, "%4d", fd);
            perror(s);
            continue;
        }

        rdev = NODEV;
        switch (statb.st_mode & S_IFMT) {
        case S_IFCHR: s = "S_IFCHR"; rdev = statb.st_rdev; break;
        case S_IFBLK: s = "S_IFBLK"; rdev = statb.st_rdev; break;
        case S_IFIFO: s = "S_IFIFO"; break;
        case S_IFDIR: s = "S_IFDIR"; break;
        case S_IFREG: s = "S_IFREG"; break;
        case S_IFLNK: s = "S_IFLNK"; break;
        case S_IFSOCK: s = "S_IFSOCK"; break;
        case S_IFDOOR: s = "S_IFDOOR"; break;
        case S_IFPORT: s = "S_IFPORT"; break;
        default:
            s = unknown;
            (void) sprintf(s, "0x%.4x ",
                (int)statb.st_mode & S_IFMT);
            break;
        }

        (void) printf("%4d: %s mode:0%.3o", fd, s,
            (int)statb.st_mode & ~S_IFMT);

        if (major(statb.st_dev) != (major_t)NODEV &&
            minor(statb.st_dev) != (minor_t)NODEV)
            (void) printf(" dev:%lu,%lu",
                (ulong_t)major(statb.st_dev),
                (ulong_t)minor(statb.st_dev));
        else
            (void) printf(" dev:0x%.8lX", (long)statb.st_dev);

        if ((statb.st_mode & S_IFMT) == S_IFPORT) {
            (void) printf(" uid:%d gid:%d",
                (int)statb.st_uid,
                (int)statb.st_gid);
            (void) printf(" size:%lld\n",
                (longlong_t)statb.st_size);
            continue;
        }

        (void) printf(" ino:%llu uid:%d gid:%d",
            (u_longlong_t)statb.st_ino,
            (int)statb.st_uid, (int)statb.st_gid);

        if (rdev == NODEV)
            (void) printf(" size:%lld\n",
                (longlong_t)statb.st_size);
        else if (major(rdev) != (major_t)NODEV &&
            minor(rdev) != (minor_t)NODEV)
            (void) printf(" rdev:%lu,%lu\n",
                (ulong_t)major(rdev), (ulong_t)minor(rdev));
        else
            (void) printf(" rdev:0x%.8lX\n", (long)rdev);

        if (!nflag) {
            off_t offset;

            dofcntl(Pr, fd,
                (statb.st_mode & (S_IFMT|S_ENFMT|S_IXGRP))
                == (S_IFREG|S_ENFMT),
                (statb.st_mode & S_IFMT) == S_IFDOOR);

            if ((statb.st_mode & S_IFMT) == S_IFSOCK)
                dosocket(Pr, fd);

            (void) sprintf(pname, "/proc/%d/path/%d", (int)pid, fd);

            if ((ret = readlink(pname, fname, PATH_MAX - 1)) <= 0)
                continue;

            fname[ret] = '\0';

            if ((statb.st_mode & S_IFMT) == S_IFCHR &&
                (dev = strrchr(fname, ':')) != NULL) {
                /*
                 * There's no elegant way to determine if a
                 * character device supports TLI, so we lame
                 * out and just check a hardcoded list of
                 * known TLI devices.
                 */
                int i;
                const char *tlidevs[] =
                    { "tcp", "tcp6", "udp", "udp6", NULL };

                dev++; /* skip past the `:' */
                for (i = 0; tlidevs[i] != NULL; i++) {
                    if (strcmp(dev, tlidevs[i]) == 0) {
                        dotli(Pr, fd);
                        break;
                    }
                }
            }
            (void) printf("      %s\n", fname);

            offset = pr_lseek(Pr, fd, 0, SEEK_CUR);
            if (offset != -1) {
                (void) printf("      offset:%ld\n", offset);
            }

        }
    }
    (void) closedir(dirp);
}


static int
getflock(struct ps_prochandle *Pr, int fd, struct flock *flock_native)
{
    int ret;
#ifdef _LP64
    struct flock64_32 flock_target;

    if (Pstatus(Pr)->pr_dmodel == PR_MODEL_ILP32) {
        copyflock(flock_target, *flock_native);
        ret = pr_fcntl(Pr, fd, F_GETLK, &flock_target);
        copyflock(*flock_native, flock_target);
        return (ret);
    }
#endif /* _LP64 */
    ret = pr_fcntl(Pr, fd, F_GETLK, flock_native);
    return (ret);
}

/* examine open file with fcntl() */
static void
dofcntl(struct ps_prochandle *Pr, int fd, int mandatory, int isdoor)
{
    struct flock flock;
    int fileflags;
    int fdflags;

    fileflags = pr_fcntl(Pr, fd, F_GETXFL, 0);
    fdflags = pr_fcntl(Pr, fd, F_GETFD, 0);

    if (fileflags != -1 || fdflags != -1) {
        (void) printf("      ");
        if (fileflags != -1)
            show_fileflags(fileflags);
        if (fdflags != -1 && (fdflags & FD_CLOEXEC))
            (void) printf(" FD_CLOEXEC");
        if (isdoor)
            show_door(Pr, fd);
        (void) fputc('\n', stdout);
    } else if (isdoor) {
        (void) printf("    ");
        show_door(Pr, fd);
        (void) fputc('\n', stdout);
    }

    flock.l_type = F_WRLCK;
    flock.l_whence = 0;
    flock.l_start = 0;
    flock.l_len = 0;
    flock.l_sysid = 0;
    flock.l_pid = 0;
    if (getflock(Pr, fd, &flock) != -1) {
        if (flock.l_type != F_UNLCK && (flock.l_sysid || flock.l_pid)) {
            unsigned long sysid = flock.l_sysid;

            (void) printf("      %s %s lock set by",
                mandatory ? "mandatory" : "advisory",
                flock.l_type == F_RDLCK? "read" : "write");
            if (sysid)
                (void) printf(" system 0x%lX", sysid);
            if (flock.l_pid)
                (void) printf(" process %d", (int)flock.l_pid);
            (void) fputc('\n', stdout);
        }
    }
}

#ifdef O_PRIV
#define ALL_O_FLAGS O_ACCMODE | O_NDELAY | O_NONBLOCK | O_APPEND | \
            O_PRIV | O_SYNC | O_DSYNC | O_RSYNC | O_XATTR | \
            O_CREAT | O_TRUNC | O_EXCL | O_NOCTTY | O_LARGEFILE
#else
#define ALL_O_FLAGS O_ACCMODE | O_NDELAY | O_NONBLOCK | O_APPEND | \
            O_SYNC | O_DSYNC | O_RSYNC | O_XATTR | \
            O_CREAT | O_TRUNC | O_EXCL | O_NOCTTY | O_LARGEFILE
#endif

static void
show_fileflags(int flags)
{
    char buffer[136];
    char *str = buffer;

    switch (flags & O_ACCMODE) {
    case O_RDONLY:
        (void) strcpy(str, "O_RDONLY");
        break;
    case O_WRONLY:
        (void) strcpy(str, "O_WRONLY");
        break;
    case O_RDWR:
        (void) strcpy(str, "O_RDWR");
        break;
    default:
        (void) sprintf(str, "0x%x", flags & O_ACCMODE);
        break;
    }

    if (flags & O_NDELAY)
        (void) strcat(str, "|O_NDELAY");
    if (flags & O_NONBLOCK)
        (void) strcat(str, "|O_NONBLOCK");
    if (flags & O_APPEND)
        (void) strcat(str, "|O_APPEND");
#ifdef O_PRIV
    if (flags & O_PRIV)
        (void) strcat(str, "|O_PRIV");
#endif
    if (flags & O_SYNC)
        (void) strcat(str, "|O_SYNC");
    if (flags & O_DSYNC)
        (void) strcat(str, "|O_DSYNC");
    if (flags & O_RSYNC)
        (void) strcat(str, "|O_RSYNC");
    if (flags & O_CREAT)
        (void) strcat(str, "|O_CREAT");
    if (flags & O_TRUNC)
        (void) strcat(str, "|O_TRUNC");
    if (flags & O_EXCL)
        (void) strcat(str, "|O_EXCL");
    if (flags & O_NOCTTY)
        (void) strcat(str, "|O_NOCTTY");
    if (flags & O_LARGEFILE)
        (void) strcat(str, "|O_LARGEFILE");
    if (flags & O_XATTR)
        (void) strcat(str, "|O_XATTR");
    if (flags & ~(ALL_O_FLAGS))
        (void) sprintf(str + strlen(str), "|0x%x",
            flags & ~(ALL_O_FLAGS));

    (void) printf("%s", str);
}

/* show door info */
static void
show_door(struct ps_prochandle *Pr, int fd)
{
    door_info_t door_info;
    psinfo_t psinfo;

    if (pr_door_info(Pr, fd, &door_info) != 0)
        return;

    if (proc_get_psinfo(door_info.di_target, &psinfo) != 0)
        psinfo.pr_fname[0] = '\0';

    (void) printf("  door to ");
    if (psinfo.pr_fname[0] != '\0')
        (void) printf("%s[%d]", psinfo.pr_fname,
            (int)door_info.di_target);
    else
        (void) printf("pid %d", (int)door_info.di_target);
}

/*
 * Print out the socket address pointed to by `sa'.  `len' is only
 * needed for AF_UNIX sockets.
 */
static void
show_sockaddr(const char *str, struct sockaddr *sa, socklen_t len)
{
    struct sockaddr_in *so_in = (struct sockaddr_in *)(void *)sa;
    struct sockaddr_in6 *so_in6 = (struct sockaddr_in6 *)(void *)sa;
    struct sockaddr_un *so_un = (struct sockaddr_un *)sa;
    char  abuf[INET6_ADDRSTRLEN];
    const char *p;

    switch (sa->sa_family) {
    default:
        return;
    case AF_INET:
        (void) printf("\t%s: AF_INET %s  port: %u\n", str,
            inet_ntop(AF_INET, &so_in->sin_addr, abuf, sizeof (abuf)),
            ntohs(so_in->sin_port));
        return;
    case AF_INET6:
        (void) printf("\t%s: AF_INET6 %s  port: %u\n", str,
            inet_ntop(AF_INET6, &so_in6->sin6_addr,
            abuf, sizeof (abuf)),
            ntohs(so_in->sin_port));
        return;
    case AF_UNIX:
        if (len >= sizeof (so_un->sun_family)) {
            /* Null terminate */
            len -= sizeof (so_un->sun_family);
            so_un->sun_path[len] = '\0';
            (void) printf("\t%s: AF_UNIX %s\n",
                str, so_un->sun_path);
        }
        return;
    case AF_IMPLINK:    p = "AF_IMPLINK";   break;
    case AF_PUP:        p = "AF_PUP";       break;
    case AF_CHAOS:      p = "AF_CHAOS";     break;
    case AF_NS:     p = "AF_NS";        break;
    case AF_NBS:        p = "AF_NBS";       break;
    case AF_ECMA:       p = "AF_ECMA";      break;
    case AF_DATAKIT:    p = "AF_DATAKIT";   break;
    case AF_CCITT:      p = "AF_CCITT";     break;
    case AF_SNA:        p = "AF_SNA";       break;
    case AF_DECnet:     p = "AF_DECnet";    break;
    case AF_DLI:        p = "AF_DLI";       break;
    case AF_LAT:        p = "AF_LAT";       break;
    case AF_HYLINK:     p = "AF_HYLINK";    break;
    case AF_APPLETALK:  p = "AF_APPLETALK"; break;
    case AF_NIT:        p = "AF_NIT";       break;
    case AF_802:        p = "AF_802";       break;
    case AF_OSI:        p = "AF_OSI";       break;
    case AF_X25:        p = "AF_X25";       break;
    case AF_OSINET:     p = "AF_OSINET";    break;
    case AF_GOSIP:      p = "AF_GOSIP";     break;
    case AF_IPX:        p = "AF_IPX";       break;
    case AF_ROUTE:      p = "AF_ROUTE";     break;
    case AF_LINK:       p = "AF_LINK";      break;
    }

    (void) printf("\t%s: %s\n", str, p);
}

static void
show_socktype(uint_t type)
{
    static const char *types[] = {
        NULL, "DGRAM", "STREAM", NULL, "RAW", "RDM", "SEQPACKET"
    };

    if (type < sizeof (types) / sizeof (*types) && types[type] != NULL)
        (void) printf("\tSOCK_%s\n", types[type]);
    else
        (void) printf("\tunknown socket type %u\n", type);
}

#define BUFSIZE 200
static void
show_sockopts(struct ps_prochandle *Pr, int fd)
{
    int val, vlen;
    char buf[BUFSIZE];
    char buf1[32];
    char ipaddr[INET_ADDRSTRLEN];
    int i;
    in_addr_t nexthop_val;
    struct boolopt {
        int     level;
        int     opt;
        const char  *name;
    };
    static struct boolopt boolopts[] = {
        { SOL_SOCKET, SO_DEBUG,     "SO_DEBUG," },
        { SOL_SOCKET, SO_REUSEADDR,     "SO_REUSEADDR," },
        { SOL_SOCKET, SO_KEEPALIVE,     "SO_KEEPALIVE," },
        { SOL_SOCKET, SO_DONTROUTE,     "SO_DONTROUTE," },
        { SOL_SOCKET, SO_BROADCAST,     "SO_BROADCAST," },
        { SOL_SOCKET, SO_OOBINLINE,     "SO_OOBINLINE," },
        { SOL_SOCKET, SO_DGRAM_ERRIND,  "SO_DGRAM_ERRIND,"},
        { SOL_SOCKET, SO_ALLZONES,      "SO_ALLZONES,"  },
        { SOL_SOCKET, SO_MAC_EXEMPT,    "SO_MAC_EXEMPT," },
        { SOL_SOCKET, SO_MAC_IMPLICIT,  "SO_MAC_IMPLICIT," },
        { SOL_SOCKET, SO_EXCLBIND,      "SO_EXCLBIND," },
        { SOL_SOCKET, SO_VRRP,      "SO_VRRP," },
        { IPPROTO_UDP, UDP_NAT_T_ENDPOINT,  "UDP_NAT_T_ENDPOINT," },
    };
    struct linger l;

    buf[0] = '!';       /* sentinel value, never printed */
    buf[1] = '\0';

    for (i = 0; i < sizeof (boolopts) / sizeof (boolopts[0]); i++) {
        vlen = sizeof (val);
        if (pr_getsockopt(Pr, fd, boolopts[i].level, boolopts[i].opt,
            &val, &vlen) == 0 && val != 0)
            (void) strlcat(buf, boolopts[i].name, sizeof (buf));
    }

    vlen = sizeof (l);
    if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_LINGER, &l, &vlen) == 0 &&
        l.l_onoff != 0) {
        (void) snprintf(buf1, sizeof (buf1), "SO_LINGER(%d),",
            l.l_linger);
        (void) strlcat(buf, buf1, sizeof (buf));
    }

    vlen = sizeof (val);
    if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_SNDBUF, &val, &vlen) == 0) {
        (void) snprintf(buf1, sizeof (buf1), "SO_SNDBUF(%d),", val);
        (void) strlcat(buf, buf1, sizeof (buf));
    }
    vlen = sizeof (val);
    if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_RCVBUF, &val, &vlen) == 0) {
        (void) snprintf(buf1, sizeof (buf1), "SO_RCVBUF(%d),", val);
        (void) strlcat(buf, buf1, sizeof (buf));
    }
    vlen = sizeof (nexthop_val);
    if (pr_getsockopt(Pr, fd, IPPROTO_IP, IP_NEXTHOP, &nexthop_val,
        &vlen) == 0) {
        if (vlen > 0) {
            (void) inet_ntop(AF_INET, (void *) &nexthop_val,
                ipaddr, sizeof (ipaddr));
            (void) snprintf(buf1, sizeof (buf1), "IP_NEXTHOP(%s),",
                ipaddr);
            (void) strlcat(buf, buf1, sizeof (buf));
        }
    }

    buf[strlen(buf) - 1] = '\0'; /* overwrites sentinel if no options */
    if (buf[1] != '\0')
        (void) printf("\t%s\n", buf+1);
}

/* the file is a socket */
static void
dosocket(struct ps_prochandle *Pr, int fd)
{
    /* A buffer large enough for PATH_MAX size AF_UNIX address */
    long buf[(sizeof (short) + PATH_MAX + sizeof (long) - 1)
        / sizeof (long)];
    struct sockaddr *sa = (struct sockaddr *)buf;
    socklen_t len;
    int type, tlen;

    tlen = sizeof (type);
    if (pr_getsockopt(Pr, fd, SOL_SOCKET, SO_TYPE, &type, &tlen) == 0)
        show_socktype((uint_t)type);

    show_sockopts(Pr, fd);

    len = sizeof (buf);
    if (pr_getsockname(Pr, fd, sa, &len) == 0)
        show_sockaddr("sockname", sa, len);

    len = sizeof (buf);
    if (pr_getpeername(Pr, fd, sa, &len) == 0)
        show_sockaddr("peername", sa, len);
}

/* the file is a TLI endpoint */
static void
dotli(struct ps_prochandle *Pr, int fd)
{
    struct strcmd strcmd;

    strcmd.sc_len = STRCMDBUFSIZE;
    strcmd.sc_timeout = 5;

    strcmd.sc_cmd = TI_GETMYNAME;
    if (pr_ioctl(Pr, fd, _I_CMD, &strcmd, sizeof (strcmd)) == 0)
        show_sockaddr("sockname", (void *)&strcmd.sc_buf, 0);

    strcmd.sc_cmd = TI_GETPEERNAME;
    if (pr_ioctl(Pr, fd, _I_CMD, &strcmd, sizeof (strcmd)) == 0)
        show_sockaddr("peername", (void *)&strcmd.sc_buf, 0);
}