1*f89edd4bSderaadt /* $OpenBSD: sendbug.c,v 1.63 2009/08/26 20:40:40 deraadt Exp $ */ 25ae6585fSray 35ae6585fSray /* 45ae6585fSray * Written by Ray Lai <ray@cyth.net>. 55ae6585fSray * Public domain. 65ae6585fSray */ 75ae6585fSray 85ae6585fSray #include <sys/types.h> 95ae6585fSray #include <sys/param.h> 105ae6585fSray #include <sys/stat.h> 115ae6585fSray #include <sys/sysctl.h> 125ae6585fSray #include <sys/wait.h> 135ae6585fSray 1449d07c37Sray #include <ctype.h> 155ae6585fSray #include <err.h> 165ae6585fSray #include <errno.h> 175ae6585fSray #include <fcntl.h> 185ae6585fSray #include <limits.h> 195ae6585fSray #include <paths.h> 205ae6585fSray #include <pwd.h> 214b9386a8Sderaadt #include <signal.h> 225ae6585fSray #include <stdio.h> 235ae6585fSray #include <stdlib.h> 245ae6585fSray #include <string.h> 255ae6585fSray #include <unistd.h> 265ae6585fSray 275ae6585fSray #include "atomicio.h" 285ae6585fSray 297d2774c0Sray #define _PATH_DMESG "/var/run/dmesg.boot" 3051cd2972Sray #define DMESG_START "OpenBSD " 318ef3815aSray #define BEGIN64 "begin-base64 " 328ef3815aSray #define END64 "====" 337d2774c0Sray 34fad7ccdbSray int checkfile(const char *); 358ef3815aSray void debase(void); 366c4efebfSray void dmesg(FILE *); 374c385748Sray int editit(const char *); 388ef3815aSray void hwdump(FILE *); 39b2e65daaStedu void init(void); 40e9d79a51Sray int matchline(const char *, const char *, size_t); 415ae6585fSray int prompt(void); 420690c094Sray int send_file(const char *, int); 435ae6585fSray int sendmail(const char *); 445ae6585fSray void template(FILE *); 455ae6585fSray 46580747f8Sray const char *categories = "system user library documentation kernel " 47580747f8Sray "alpha amd64 arm hppa i386 m68k m88k mips64 powerpc sh sparc sparc64 vax"; 48823e89efSderaadt char *version = "4.2"; 49c952560cSray const char *comment[] = { 50c952560cSray "<synopsis of the problem (one line)>", 51580747f8Sray "<PR category (one line)>", 52c952560cSray "<precise description of the problem (multiple lines)>", 53c952560cSray "<code/input/activities to reproduce the problem (multiple lines)>", 54c952560cSray "<how to correct or work around the problem, if known (multiple lines)>" 55c952560cSray }; 56823e89efSderaadt 57823e89efSderaadt struct passwd *pw; 58e051e8faSderaadt char os[BUFSIZ], rel[BUFSIZ], mach[BUFSIZ], details[BUFSIZ]; 598ef3815aSray const char *tmpdir; 606e192cfdSray char *tmppath; 615eb46beaSderaadt int Dflag, Pflag, wantcleanup; 62823e89efSderaadt 63b2e65daaStedu __dead void 64903e61cbSderaadt usage(void) 65903e61cbSderaadt { 66946adaceSray extern char *__progname; 67946adaceSray 688ef3815aSray fprintf(stderr, "usage: %s [-DEPV]\n", __progname); 69b2e65daaStedu exit(1); 70903e61cbSderaadt } 71903e61cbSderaadt 72b2e65daaStedu void 73b2e65daaStedu cleanup() 74b2e65daaStedu { 75b2e65daaStedu if (wantcleanup && tmppath && unlink(tmppath) == -1) 76b2e65daaStedu warn("unlink"); 77b2e65daaStedu } 78b2e65daaStedu 79b2e65daaStedu 805ae6585fSray int 815ae6585fSray main(int argc, char *argv[]) 825ae6585fSray { 83aad8b29bSray int ch, c, fd, ret = 1; 8470dfcc75Sderaadt struct stat sb; 85f4348cb9Sderaadt char *pr_form; 8670dfcc75Sderaadt time_t mtime; 8770dfcc75Sderaadt FILE *fp; 885ae6585fSray 898ef3815aSray while ((ch = getopt(argc, argv, "DEPV")) != -1) 90903e61cbSderaadt switch (ch) { 917d2774c0Sray case 'D': 927d2774c0Sray Dflag = 1; 937d2774c0Sray break; 948ef3815aSray case 'E': 958ef3815aSray debase(); 968ef3815aSray exit(0); 97903e61cbSderaadt case 'P': 985eb46beaSderaadt Pflag = 1; 995eb46beaSderaadt break; 1005711e205Sderaadt case 'V': 1015711e205Sderaadt printf("%s\n", version); 1025711e205Sderaadt exit(0); 103903e61cbSderaadt default: 104903e61cbSderaadt usage(); 105903e61cbSderaadt } 1067d2774c0Sray argc -= optind; 1077d2774c0Sray argv += optind; 108903e61cbSderaadt 109f76e53adSray if (argc > 0) 110903e61cbSderaadt usage(); 111903e61cbSderaadt 112*f89edd4bSderaadt if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0') 113*f89edd4bSderaadt tmpdir = _PATH_TMP; 114*f89edd4bSderaadt 1155eb46beaSderaadt if (Pflag) { 1165eb46beaSderaadt init(); 1175eb46beaSderaadt template(stdout); 1185eb46beaSderaadt exit(0); 1195eb46beaSderaadt } 1205eb46beaSderaadt 121795a8b97Sray if (asprintf(&tmppath, "%s%sp.XXXXXXXXXX", tmpdir, 122f4348cb9Sderaadt tmpdir[strlen(tmpdir) - 1] == '/' ? "" : "/") == -1) 123b2e65daaStedu err(1, "asprintf"); 1245ae6585fSray if ((fd = mkstemp(tmppath)) == -1) 1255ae6585fSray err(1, "mkstemp"); 126b2e65daaStedu wantcleanup = 1; 127b2e65daaStedu atexit(cleanup); 128f4348cb9Sderaadt if ((fp = fdopen(fd, "w+")) == NULL) 129b2e65daaStedu err(1, "fdopen"); 1305ae6585fSray 131b2e65daaStedu init(); 1325ae6585fSray 1334ff3398aSderaadt pr_form = getenv("PR_FORM"); 1344ff3398aSderaadt if (pr_form) { 1354ff3398aSderaadt char buf[BUFSIZ]; 1364ff3398aSderaadt size_t len; 1374ff3398aSderaadt FILE *frfp; 1384ff3398aSderaadt 1394ff3398aSderaadt frfp = fopen(pr_form, "r"); 1404ff3398aSderaadt if (frfp == NULL) { 141946adaceSray warn("can't seem to read your template file " 142946adaceSray "(`%s'), ignoring PR_FORM", pr_form); 1434ff3398aSderaadt template(fp); 1444ff3398aSderaadt } else { 1454ff3398aSderaadt while (!feof(frfp)) { 1464ff3398aSderaadt len = fread(buf, 1, sizeof buf, frfp); 1474ff3398aSderaadt if (len == 0) 1484ff3398aSderaadt break; 1494ff3398aSderaadt if (fwrite(buf, 1, len, fp) != len) 1504ff3398aSderaadt break; 1514ff3398aSderaadt } 1524ff3398aSderaadt fclose(frfp); 1534ff3398aSderaadt } 154aad8b29bSray } else 1555ae6585fSray template(fp); 1565ae6585fSray 157f4348cb9Sderaadt if (fflush(fp) == EOF || fstat(fd, &sb) == -1 || fclose(fp) == EOF) 158b2e65daaStedu err(1, "error creating template"); 1595ae6585fSray mtime = sb.st_mtime; 1605ae6585fSray 1615ae6585fSray edit: 1623bdb63c6Sray if (editit(tmppath) == -1) 163648f0ffcSray err(1, "error running editor"); 1645ae6585fSray 165f4348cb9Sderaadt if (stat(tmppath, &sb) == -1) 166b2e65daaStedu err(1, "stat"); 167f4348cb9Sderaadt if (mtime == sb.st_mtime) 168b2e65daaStedu errx(1, "report unchanged, nothing sent"); 1695ae6585fSray 1705ae6585fSray prompt: 171fad7ccdbSray if (!checkfile(tmppath)) 172fad7ccdbSray fprintf(stderr, "fields are blank, must be filled in\n"); 1735ae6585fSray c = prompt(); 1745ae6585fSray switch (c) { 1755711e205Sderaadt case 'a': 1765711e205Sderaadt case EOF: 177b2e65daaStedu wantcleanup = 0; 178b2e65daaStedu errx(1, "unsent report in %s", tmppath); 1795ae6585fSray case 'e': 1805ae6585fSray goto edit; 1815ae6585fSray case 's': 1825ae6585fSray if (sendmail(tmppath) == -1) 1835ae6585fSray goto quit; 1845ae6585fSray break; 1855ae6585fSray default: 1865ae6585fSray goto prompt; 1875ae6585fSray } 1885ae6585fSray 1895ae6585fSray ret = 0; 1905ae6585fSray quit: 1915ae6585fSray return (ret); 1925ae6585fSray } 1935ae6585fSray 1946c4efebfSray void 1956c4efebfSray dmesg(FILE *fp) 1966c4efebfSray { 1976c4efebfSray char buf[BUFSIZ]; 1986c4efebfSray FILE *dfp; 1996c4efebfSray off_t offset = -1; 2006c4efebfSray 2016c4efebfSray dfp = fopen(_PATH_DMESG, "r"); 2026c4efebfSray if (dfp == NULL) { 2036c4efebfSray warn("can't read dmesg"); 2046c4efebfSray return; 2056c4efebfSray } 2066c4efebfSray 20751cd2972Sray /* Find last dmesg. */ 2086c4efebfSray for (;;) { 2096c4efebfSray off_t o; 2106c4efebfSray 2116c4efebfSray o = ftello(dfp); 2126c4efebfSray if (fgets(buf, sizeof(buf), dfp) == NULL) 2136c4efebfSray break; 21451cd2972Sray if (!strncmp(DMESG_START, buf, sizeof(DMESG_START) - 1)) 2156c4efebfSray offset = o; 2166c4efebfSray } 2176c4efebfSray if (offset != -1) { 2186c4efebfSray size_t len; 2196c4efebfSray 2206c4efebfSray clearerr(dfp); 2216c4efebfSray fseeko(dfp, offset, SEEK_SET); 2226c4efebfSray while (offset != -1 && !feof(dfp)) { 2236c4efebfSray len = fread(buf, 1, sizeof buf, dfp); 2246c4efebfSray if (len == 0) 2256c4efebfSray break; 2266c4efebfSray if (fwrite(buf, 1, len, fp) != len) 2276c4efebfSray break; 2286c4efebfSray } 2296c4efebfSray } 2306c4efebfSray fclose(dfp); 2316c4efebfSray } 2326c4efebfSray 2333bdb63c6Sray /* 2343bdb63c6Sray * Execute an editor on the specified pathname, which is interpreted 2353bdb63c6Sray * from the shell. This means flags may be included. 2363bdb63c6Sray * 2373bdb63c6Sray * Returns -1 on error, or the exit value on success. 2383bdb63c6Sray */ 2394b9386a8Sderaadt int 2404c385748Sray editit(const char *pathname) 2414b9386a8Sderaadt { 242f4348cb9Sderaadt char *argp[] = {"sh", "-c", NULL, NULL}, *ed, *p; 24343316b18Sderaadt sig_t sighup, sigint, sigquit, sigchld; 2444c385748Sray pid_t pid; 24543316b18Sderaadt int saved_errno, st, ret = -1; 2464b9386a8Sderaadt 247c8a426adSray ed = getenv("VISUAL"); 248c8a426adSray if (ed == NULL || ed[0] == '\0') 249c8a426adSray ed = getenv("EDITOR"); 250c8a426adSray if (ed == NULL || ed[0] == '\0') 2514b9386a8Sderaadt ed = _PATH_VI; 252292bd7edSray if (asprintf(&p, "%s %s", ed, pathname) == -1) 2538af53ff7Sray return (-1); 2544b9386a8Sderaadt argp[2] = p; 2554b9386a8Sderaadt 2568ec2d82eSray sighup = signal(SIGHUP, SIG_IGN); 2578ec2d82eSray sigint = signal(SIGINT, SIG_IGN); 2588ec2d82eSray sigquit = signal(SIGQUIT, SIG_IGN); 25943316b18Sderaadt sigchld = signal(SIGCHLD, SIG_DFL); 260ae6b53b5Sray if ((pid = fork()) == -1) 2613cf7ad38Sray goto fail; 2624b9386a8Sderaadt if (pid == 0) { 2634b9386a8Sderaadt execv(_PATH_BSHELL, argp); 2644b9386a8Sderaadt _exit(127); 2654b9386a8Sderaadt } 2663cf7ad38Sray while (waitpid(pid, &st, 0) == -1) 2673cf7ad38Sray if (errno != EINTR) 2683cf7ad38Sray goto fail; 26943316b18Sderaadt if (!WIFEXITED(st)) 2703bdb63c6Sray errno = EINTR; 27143316b18Sderaadt else 27243316b18Sderaadt ret = WEXITSTATUS(st); 2733cf7ad38Sray 2743cf7ad38Sray fail: 2753cf7ad38Sray saved_errno = errno; 2763cf7ad38Sray (void)signal(SIGHUP, sighup); 2773cf7ad38Sray (void)signal(SIGINT, sigint); 2783cf7ad38Sray (void)signal(SIGQUIT, sigquit); 27943316b18Sderaadt (void)signal(SIGCHLD, sigchld); 2803cf7ad38Sray free(p); 2813cf7ad38Sray errno = saved_errno; 28243316b18Sderaadt return (ret); 2834b9386a8Sderaadt } 284b2e65daaStedu 2855ae6585fSray int 2865ae6585fSray prompt(void) 2875ae6585fSray { 2885ae6585fSray int c, ret; 2895ae6585fSray 2905ae6585fSray fpurge(stdin); 2915ae6585fSray fprintf(stderr, "a)bort, e)dit, or s)end: "); 2925ae6585fSray fflush(stderr); 2935ae6585fSray ret = getchar(); 2945ae6585fSray if (ret == EOF || ret == '\n') 2955ae6585fSray return (ret); 2965ae6585fSray do { 2975ae6585fSray c = getchar(); 2985ae6585fSray } while (c != EOF && c != '\n'); 2995ae6585fSray return (ret); 3005ae6585fSray } 3015ae6585fSray 3025ae6585fSray int 303292bd7edSray sendmail(const char *pathname) 3045ae6585fSray { 3055ae6585fSray int filedes[2]; 3065ae6585fSray 3075ae6585fSray if (pipe(filedes) == -1) { 308292bd7edSray warn("pipe: unsent report in %s", pathname); 3095ae6585fSray return (-1); 3105ae6585fSray } 3115ae6585fSray switch (fork()) { 3125ae6585fSray case -1: 3135ae6585fSray warn("fork error: unsent report in %s", 314292bd7edSray pathname); 3155ae6585fSray return (-1); 3165ae6585fSray case 0: 3175ae6585fSray close(filedes[1]); 3185ae6585fSray if (dup2(filedes[0], STDIN_FILENO) == -1) { 3195ae6585fSray warn("dup2 error: unsent report in %s", 320292bd7edSray pathname); 3215ae6585fSray return (-1); 3225ae6585fSray } 3235ae6585fSray close(filedes[0]); 3246530cc94Schl execl(_PATH_SENDMAIL, "sendmail", 32570dfcc75Sderaadt "-oi", "-t", (void *)NULL); 3265ae6585fSray warn("sendmail error: unsent report in %s", 327292bd7edSray pathname); 3285ae6585fSray return (-1); 3295ae6585fSray default: 3305ae6585fSray close(filedes[0]); 3315ae6585fSray /* Pipe into sendmail. */ 332292bd7edSray if (send_file(pathname, filedes[1]) == -1) { 3335ae6585fSray warn("send_file error: unsent report in %s", 334292bd7edSray pathname); 3355ae6585fSray return (-1); 3365ae6585fSray } 3375ae6585fSray close(filedes[1]); 3385ae6585fSray wait(NULL); 3395ae6585fSray break; 3405ae6585fSray } 3415ae6585fSray return (0); 3425ae6585fSray } 3435ae6585fSray 344b2e65daaStedu void 3455ae6585fSray init(void) 3465ae6585fSray { 3476e192cfdSray size_t len; 348f4348cb9Sderaadt int sysname[2]; 3496e192cfdSray char *cp; 3505ae6585fSray 351f4348cb9Sderaadt if ((pw = getpwuid(getuid())) == NULL) 352b2e65daaStedu err(1, "getpwuid"); 3535ae6585fSray 3545ae6585fSray sysname[0] = CTL_KERN; 3555ae6585fSray sysname[1] = KERN_OSTYPE; 3565ae6585fSray len = sizeof(os) - 1; 357f4348cb9Sderaadt if (sysctl(sysname, 2, &os, &len, NULL, 0) == -1) 358b2e65daaStedu err(1, "sysctl"); 3595ae6585fSray 3605ae6585fSray sysname[0] = CTL_KERN; 3615ae6585fSray sysname[1] = KERN_OSRELEASE; 3625ae6585fSray len = sizeof(rel) - 1; 363f4348cb9Sderaadt if (sysctl(sysname, 2, &rel, &len, NULL, 0) == -1) 364b2e65daaStedu err(1, "sysctl"); 3655ae6585fSray 366e051e8faSderaadt sysname[0] = CTL_KERN; 367e051e8faSderaadt sysname[1] = KERN_VERSION; 368e051e8faSderaadt len = sizeof(details) - 1; 369f4348cb9Sderaadt if (sysctl(sysname, 2, &details, &len, NULL, 0) == -1) 370e051e8faSderaadt err(1, "sysctl"); 371e051e8faSderaadt 372e051e8faSderaadt cp = strchr(details, '\n'); 373e051e8faSderaadt if (cp) { 374e051e8faSderaadt cp++; 375e051e8faSderaadt if (*cp) 376e051e8faSderaadt *cp++ = '\t'; 377e051e8faSderaadt if (*cp) 378e051e8faSderaadt *cp++ = '\t'; 379e051e8faSderaadt if (*cp) 380e051e8faSderaadt *cp++ = '\t'; 381e051e8faSderaadt } 382e051e8faSderaadt 3835ae6585fSray sysname[0] = CTL_HW; 3845ae6585fSray sysname[1] = HW_MACHINE; 3855ae6585fSray len = sizeof(mach) - 1; 386f4348cb9Sderaadt if (sysctl(sysname, 2, &mach, &len, NULL, 0) == -1) 387b2e65daaStedu err(1, "sysctl"); 3885ae6585fSray } 3895ae6585fSray 3905ae6585fSray int 3915ae6585fSray send_file(const char *file, int dst) 3925ae6585fSray { 39370dfcc75Sderaadt size_t len; 39454cc23aeSray char *buf, *lbuf; 39570dfcc75Sderaadt FILE *fp; 39654cc23aeSray int rval = -1, saved_errno; 3975ae6585fSray 3985ae6585fSray if ((fp = fopen(file, "r")) == NULL) 3995ae6585fSray return (-1); 40054cc23aeSray lbuf = NULL; 4015ae6585fSray while ((buf = fgetln(fp, &len))) { 402b2c335bbSray if (buf[len - 1] == '\n') { 40354cc23aeSray buf[len - 1] = '\0'; 404b2c335bbSray --len; 405b2c335bbSray } else { 40654cc23aeSray /* EOF without EOL, copy and add the NUL */ 40754cc23aeSray if ((lbuf = malloc(len + 1)) == NULL) 40854cc23aeSray goto end; 40954cc23aeSray memcpy(lbuf, buf, len); 41054cc23aeSray lbuf[len] = '\0'; 41154cc23aeSray buf = lbuf; 41254cc23aeSray } 41354cc23aeSray 4145ae6585fSray /* Skip lines starting with "SENDBUG". */ 41554cc23aeSray if (strncmp(buf, "SENDBUG", sizeof("SENDBUG") - 1) == 0) 4165ae6585fSray continue; 4175ae6585fSray while (len) { 418e051e8faSderaadt char *sp = NULL, *ep = NULL; 4195ae6585fSray size_t copylen; 4205ae6585fSray 42154cc23aeSray if ((sp = strchr(buf, '<')) != NULL) { 42254cc23aeSray size_t i; 42354cc23aeSray 42454cc23aeSray for (i = 0; i < sizeof(comment) / sizeof(*comment); ++i) { 42554cc23aeSray size_t commentlen = strlen(comment[i]); 42654cc23aeSray 42754cc23aeSray if (strncmp(sp, comment[i], commentlen) == 0) { 42854cc23aeSray ep = sp + commentlen - 1; 42954cc23aeSray break; 43054cc23aeSray } 43154cc23aeSray } 43254cc23aeSray } 4335ae6585fSray /* Length of string before comment. */ 4348cf86b71Sray if (ep) 4358cf86b71Sray copylen = sp - buf; 4368cf86b71Sray else 4378cf86b71Sray copylen = len; 438b2c335bbSray if (atomicio(vwrite, dst, buf, copylen) != copylen) 43954cc23aeSray goto end; 4405ae6585fSray if (!ep) 4415ae6585fSray break; 4425ae6585fSray /* Skip comment. */ 4435ae6585fSray len -= ep - buf + 1; 4445ae6585fSray buf = ep + 1; 4455ae6585fSray } 446b2c335bbSray if (atomicio(vwrite, dst, "\n", 1) != 1) 447b2c335bbSray goto end; 4485ae6585fSray } 44954cc23aeSray rval = 0; 45054cc23aeSray end: 45154cc23aeSray saved_errno = errno; 45254cc23aeSray free(lbuf); 4535ae6585fSray fclose(fp); 45454cc23aeSray errno = saved_errno; 45554cc23aeSray return (rval); 4565ae6585fSray } 4575ae6585fSray 458fad7ccdbSray /* 459fad7ccdbSray * Does line start with `s' and end with non-comment and non-whitespace? 460e9d79a51Sray * Note: Does not treat `line' as a C string. 461fad7ccdbSray */ 462fad7ccdbSray int 463e9d79a51Sray matchline(const char *s, const char *line, size_t linelen) 464fad7ccdbSray { 465fad7ccdbSray size_t slen; 466c952560cSray int iscomment; 467fad7ccdbSray 468fad7ccdbSray slen = strlen(s); 469fad7ccdbSray /* Is line shorter than string? */ 470fad7ccdbSray if (linelen <= slen) 471fad7ccdbSray return (0); 472fad7ccdbSray /* Does line start with string? */ 473fad7ccdbSray if (memcmp(line, s, slen) != 0) 474fad7ccdbSray return (0); 475fad7ccdbSray /* Does line contain anything but comments and whitespace? */ 476fad7ccdbSray line += slen; 477fad7ccdbSray linelen -= slen; 478c952560cSray iscomment = 0; 479fad7ccdbSray while (linelen) { 480c952560cSray if (iscomment) { 481fad7ccdbSray if (*line == '>') 482c952560cSray iscomment = 0; 483fad7ccdbSray } else if (*line == '<') 484c952560cSray iscomment = 1; 485e9d79a51Sray else if (!isspace((unsigned char)*line)) 486fad7ccdbSray return (1); 487fad7ccdbSray ++line; 488fad7ccdbSray --linelen; 489fad7ccdbSray } 490fad7ccdbSray return (0); 491fad7ccdbSray } 492fad7ccdbSray 493fad7ccdbSray /* 494fad7ccdbSray * Are all required fields filled out? 495fad7ccdbSray */ 496fad7ccdbSray int 497fad7ccdbSray checkfile(const char *pathname) 498fad7ccdbSray { 499fad7ccdbSray FILE *fp; 500fad7ccdbSray size_t len; 501580747f8Sray int category = 0, synopsis = 0; 502fad7ccdbSray char *buf; 503fad7ccdbSray 504fad7ccdbSray if ((fp = fopen(pathname, "r")) == NULL) { 505fad7ccdbSray warn("%s", pathname); 506fad7ccdbSray return (0); 507fad7ccdbSray } 508fad7ccdbSray while ((buf = fgetln(fp, &len))) { 509580747f8Sray if (matchline(">Category:", buf, len)) 510580747f8Sray category = 1; 511580747f8Sray else if (matchline(">Synopsis:", buf, len)) 512580747f8Sray synopsis = 1; 513fad7ccdbSray } 514fad7ccdbSray fclose(fp); 515580747f8Sray return (category && synopsis); 516fad7ccdbSray } 517fad7ccdbSray 5185ae6585fSray void 5195ae6585fSray template(FILE *fp) 5205ae6585fSray { 5215ae6585fSray fprintf(fp, "SENDBUG: -*- sendbug -*-\n"); 522f4348cb9Sderaadt fprintf(fp, "SENDBUG: Lines starting with `SENDBUG' will" 52354cc23aeSray " be removed automatically.\n"); 5245ae6585fSray fprintf(fp, "SENDBUG:\n"); 525580747f8Sray fprintf(fp, "SENDBUG: Choose from the following categories:\n"); 526580747f8Sray fprintf(fp, "SENDBUG:\n"); 527580747f8Sray fprintf(fp, "SENDBUG: %s\n", categories); 528580747f8Sray fprintf(fp, "SENDBUG:\n"); 529580747f8Sray fprintf(fp, "SENDBUG:\n"); 5305ae6585fSray fprintf(fp, "To: %s\n", "gnats@openbsd.org"); 5315ae6585fSray fprintf(fp, "Subject: \n"); 5325ae6585fSray fprintf(fp, "From: %s\n", pw->pw_name); 533d23b3302Sray fprintf(fp, "Cc: %s\n", pw->pw_name); 5345ae6585fSray fprintf(fp, "Reply-To: %s\n", pw->pw_name); 5355ae6585fSray fprintf(fp, "\n"); 536c952560cSray fprintf(fp, ">Synopsis:\t%s\n", comment[0]); 537580747f8Sray fprintf(fp, ">Category:\t%s\n", comment[1]); 5385ae6585fSray fprintf(fp, ">Environment:\n"); 5395ae6585fSray fprintf(fp, "\tSystem : %s %s\n", os, rel); 540e051e8faSderaadt fprintf(fp, "\tDetails : %s\n", details); 5415ae6585fSray fprintf(fp, "\tArchitecture: %s.%s\n", os, mach); 5425ae6585fSray fprintf(fp, "\tMachine : %s\n", mach); 5435ae6585fSray fprintf(fp, ">Description:\n"); 54422970bc8Sray fprintf(fp, "\t%s\n", comment[2]); 545580747f8Sray fprintf(fp, ">How-To-Repeat:\n"); 54622970bc8Sray fprintf(fp, "\t%s\n", comment[3]); 547580747f8Sray fprintf(fp, ">Fix:\n"); 548580747f8Sray fprintf(fp, "\t%s\n", comment[4]); 549aad8b29bSray 5508ef3815aSray if (!Dflag) { 5518ef3815aSray int root; 5528ef3815aSray 5538ef3815aSray fprintf(fp, "\n"); 5548ef3815aSray root = !geteuid(); 5558ef3815aSray if (!root) 5568ef3815aSray fprintf(fp, "SENDBUG: Run sendbug as root " 5578ef3815aSray "if this is an ACPI report!\n"); 5588ef3815aSray fprintf(fp, "SENDBUG: dmesg%s attached.\n" 5598ef3815aSray "SENDBUG: Feel free to delete or use the -D flag if it " 5608ef3815aSray "contains sensitive information.\n", 5618ef3815aSray root ? ", pcidump, and acpidump are" : " is"); 5628ef3815aSray fputs("\ndmesg:\n", fp); 563aad8b29bSray dmesg(fp); 5648ef3815aSray if (root) 5658ef3815aSray hwdump(fp); 5668ef3815aSray } 5678ef3815aSray } 5688ef3815aSray 5698ef3815aSray void 5708ef3815aSray hwdump(FILE *ofp) 5718ef3815aSray { 5728ef3815aSray char buf[BUFSIZ]; 5738ef3815aSray FILE *ifp; 5748ef3815aSray char *cmd, *acpidir; 5758ef3815aSray size_t len; 5768ef3815aSray 5778ef3815aSray if (gethostname(buf, sizeof(buf)) == -1) 5788ef3815aSray err(1, "gethostname"); 5798ef3815aSray buf[strcspn(buf, ".")] = '\0'; 5808ef3815aSray 5818ef3815aSray if (asprintf(&acpidir, "%s%sp.XXXXXXXXXX", tmpdir, 5828ef3815aSray tmpdir[strlen(tmpdir) - 1] == '/' ? "" : "/") == -1) 5838ef3815aSray err(1, "asprintf"); 5848ef3815aSray if (mkdtemp(acpidir) == NULL) 5858ef3815aSray err(1, "mkdtemp"); 5868ef3815aSray 5878ef3815aSray if (asprintf(&cmd, "echo \"\\npcidump:\"; pcidump -xxv; " 5888ef3815aSray "echo \"\\nacpidump:\"; cd %s && acpidump -o %s; " 5898ef3815aSray "for i in *; do b64encode $i $i; done; rm -rf %s", 5908ef3815aSray acpidir, buf, acpidir) == -1) 5918ef3815aSray err(1, "asprintf"); 5928ef3815aSray 5938ef3815aSray if ((ifp = popen(cmd, "r")) != NULL) { 5948ef3815aSray while (!feof(ifp)) { 5958ef3815aSray len = fread(buf, 1, sizeof buf, ifp); 5968ef3815aSray if (len == 0) 5978ef3815aSray break; 5988ef3815aSray if (fwrite(buf, 1, len, ofp) != len) 5998ef3815aSray break; 6008ef3815aSray } 6018ef3815aSray pclose(ofp); 6028ef3815aSray } 6038ef3815aSray free(cmd); 6048ef3815aSray } 6058ef3815aSray 6068ef3815aSray void 6078ef3815aSray debase(void) 6088ef3815aSray { 6098ef3815aSray char buf[BUFSIZ]; 6108ef3815aSray FILE *fp = NULL; 6118ef3815aSray size_t len; 6128ef3815aSray 6138ef3815aSray while (fgets(buf, sizeof(buf), stdin) != NULL) { 6148ef3815aSray len = strlen(buf); 6158ef3815aSray if (!strncmp(buf, BEGIN64, sizeof(BEGIN64) - 1)) { 6168ef3815aSray if (fp) 6178ef3815aSray errx(1, "double begin"); 6188ef3815aSray fp = popen("b64decode", "w"); 6198ef3815aSray if (!fp) 6208ef3815aSray errx(1, "popen b64decode"); 6218ef3815aSray } 6228ef3815aSray if (fp && fwrite(buf, 1, len, fp) != len) 6238ef3815aSray errx(1, "pipe error"); 6248ef3815aSray if (!strncmp(buf, END64, sizeof(END64) - 1)) { 6258ef3815aSray if (pclose(fp) == -1) 6268ef3815aSray errx(1, "pclose b64decode"); 6278ef3815aSray fp = NULL; 6288ef3815aSray } 6298ef3815aSray } 6305ae6585fSray } 631