/* $OpenBSD: client.c,v 1.21 2009/02/15 22:20:54 deraadt Exp $ */ /* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "defs.h" #include "y.tab.h" #ifndef lint #if 0 static char RCSid[] __attribute__((__unused__)) = "$From: client.c,v 1.13 1999/11/01 00:22:14 christos Exp $"; #else static char RCSid[] __attribute__((__unused__)) = "$OpenBSD: client.c,v 1.21 2009/02/15 22:20:54 deraadt Exp $"; #endif static char sccsid[] __attribute__((__unused__)) = "@(#)client.c"; static char copyright[] __attribute__((__unused__)) = "@(#) Copyright (c) 1983 Regents of the University of California.\n\ All rights reserved.\n"; #endif /* not lint */ /* * Routines used in client mode to communicate with remove server. */ /* * Update status */ #define US_NOTHING 0 /* No update needed */ #define US_NOENT 1 /* Entry does not exist */ #define US_OUTDATE 2 /* Entry is out of date */ #define US_DOCOMP 3 /* Do a binary comparison */ #define US_CHMOG 4 /* Modes or ownership of file differ */ struct linkbuf *ihead = NULL; /* list of files with more than one link */ char buf[BUFSIZ]; /* general purpose buffer */ u_char respbuff[BUFSIZ]; /* Response buffer */ char target[BUFSIZ]; /* target/source directory name */ char source[BUFSIZ]; /* source directory name */ char *ptarget; /* pointer to end of target name */ char *Tdest; /* pointer to last T dest*/ struct namelist *updfilelist = NULL; /* List of updated files */ static void runspecial(char *, opt_t, char *, int); static void addcmdspecialfile(char *, char *, int); static void freecmdspecialfiles(void); static struct linkbuf *linkinfo(struct stat *); static int sendhardlink(opt_t, struct linkbuf *, char *, int); static int sendfile(char *, opt_t, struct stat *, char *, char *, int); static int rmchk(opt_t); static int senddir(char *, opt_t, struct stat *, char *, char *, int); static int sendlink(char *, opt_t, struct stat *, char *, char *, int); static int update(char *, opt_t, struct stat *); static int dostat(char *, struct stat *, opt_t); static int statupdate(int, char *, opt_t, char *, int, struct stat *, char *, char *); static int fullupdate(int, char *, opt_t, char *, int, struct stat *, char *, char *); static int sendit(char *, opt_t, int); /* * return remote file pathname (relative from target) */ char * remfilename(char *src, char *dest, char *path, char *rname, int destdir) { extern struct namelist *filelist; char *lname, *cp; static char buff[BUFSIZ]; int srclen, pathlen; char *p; debugmsg(DM_MISC, "remfilename: src=%s dest=%s path=%s rname=%s destdir=%d\n", A(src), A(dest), A(path), A(rname), destdir); if (!dest) { debugmsg(DM_MISC, "remfilename: remote filename=%s\n", path); return(path); } if (!destdir) { debugmsg(DM_MISC, "remfilename: remote filename=%s\n", dest); return(dest); } buff[0] = CNULL; lname = buff; if (path && *path) { cp = strrchr(path, '/'); if (cp == NULL) (void) snprintf(buff, sizeof(buff), "%s/%s", dest, path); else { srclen = strlen(src); pathlen = strlen(path); if (srclen >= pathlen) cp++; /* xbasename(path) */ else { if (filelist && filelist->n_next == NULL) /* path relative to src */ cp = path + srclen; else { if ((p = strrchr(src, '/'))) cp = path + srclen - strlen(p); else cp = path; } } if ((*cp != '/') && *cp) (void) snprintf(buff, sizeof(buff), "%s/%s", dest, cp); else (void) snprintf(buff, sizeof(buff), "%s%s", dest, cp); } } else (void) strlcpy(lname, dest, buf + sizeof buff - lname); debugmsg(DM_MISC, "remfilename: remote filename=%s\n", lname); return(lname); } /* * Return true if name is in the list. */ int inlist(struct namelist *list, char *file) { struct namelist *nl; for (nl = list; nl != NULL; nl = nl->n_next) if (strcmp(file, nl->n_name) == 0) return(1); return(0); } /* * Run any special commands for this file */ static void runspecial(char *starget, opt_t opts, char *rname, int destdir) { struct subcmd *sc; extern struct subcmd *subcmds; char *rfile; rfile = remfilename(source, Tdest, target, rname, destdir); for (sc = subcmds; sc != NULL; sc = sc->sc_next) { if (sc->sc_type != SPECIAL) continue; if (sc->sc_args != NULL && !inlist(sc->sc_args, starget)) continue; message(MT_CHANGE, "special \"%s\"", sc->sc_name); if (IS_ON(opts, DO_VERIFY)) continue; (void) sendcmd(C_SPECIAL, "%s=%s;%s=%s;%s=%s;export %s %s %s;%s", E_LOCFILE, starget, E_REMFILE, rfile, E_BASEFILE, xbasename(rfile), E_LOCFILE, E_REMFILE, E_BASEFILE, sc->sc_name); while (response() > 0) ; } } /* * If we're doing a target with a "cmdspecial" in it, then * save the name of the file being updated for use with "cmdspecial". */ static void addcmdspecialfile(char *starget, char *rname, int destdir) { char *rfile; struct namelist *new; struct subcmd *sc; extern struct subcmd *subcmds; int isokay = 0; rfile = remfilename(source, Tdest, target, rname, destdir); for (sc = subcmds; sc != NULL && !isokay; sc = sc->sc_next) { if (sc->sc_type != CMDSPECIAL) continue; if (sc->sc_args != NULL && !inlist(sc->sc_args, starget)) continue; isokay = TRUE; } if (isokay) { new = (struct namelist *) xmalloc(sizeof(struct namelist)); new->n_name = xstrdup(rfile); new->n_regex = NULL; new->n_next = updfilelist; updfilelist = new; } } /* * Free the file list */ static void freecmdspecialfiles(void) { struct namelist *ptr, *save; for (ptr = updfilelist; ptr; ) { if (ptr->n_name) (void) free(ptr->n_name); save = ptr->n_next; (void) free(ptr); if (save) ptr = save->n_next; else ptr = NULL; } updfilelist = NULL; } /* * Run commands for an entire cmd */ void runcmdspecial(struct cmd *cmd, opt_t opts) { struct subcmd *sc; struct namelist *f; int first = TRUE; for (sc = cmd->c_cmds; sc != NULL; sc = sc->sc_next) { if (sc->sc_type != CMDSPECIAL) continue; message(MT_CHANGE, "cmdspecial \"%s\"", sc->sc_name); if (IS_ON(opts, DO_VERIFY)) continue; /* Send all the file names */ for (f = updfilelist; f != NULL; f = f->n_next) { if (first) { (void) sendcmd(C_CMDSPECIAL, NULL); if (response() < 0) return; first = FALSE; } (void) sendcmd(RC_FILE, f->n_name); if (response() < 0) return; } if (first) { (void) sendcmd(C_CMDSPECIAL, NULL); if (response() < 0) return; first = FALSE; } /* Send command to run and wait for it to complete */ (void) sendcmd(RC_COMMAND, sc->sc_name); while (response() > 0) ; first = TRUE; /* Reset in case there are more CMDSPECIAL's */ } freecmdspecialfiles(); } /* * For security, reject filenames that contains a newline */ int checkfilename(char *name) { char *cp; if (strchr(name, '\n')) { for (cp = name; *cp; cp++) if (*cp == '\n') *cp = '?'; message(MT_NERROR, "Refuse to handle filename containing newline: %s", name); return(-1); } return(0); } void freelinkinfo(struct linkbuf *lp) { if (lp->pathname) free(lp->pathname); if (lp->src) free(lp->src); if (lp->target) free(lp->target); free(lp); } /* * Save and retrieve hard link info */ static struct linkbuf * linkinfo(struct stat *statp) { struct linkbuf *lp; /* XXX - linear search doesn't scale with many links */ for (lp = ihead; lp != NULL; lp = lp->nextp) if (lp->inum == statp->st_ino && lp->devnum == statp->st_dev) { lp->count--; return(lp); } lp = (struct linkbuf *) xmalloc(sizeof(*lp)); lp->nextp = ihead; ihead = lp; lp->inum = statp->st_ino; lp->devnum = statp->st_dev; lp->count = statp->st_nlink - 1; lp->pathname = xstrdup(target); lp->src = xstrdup(source); if (Tdest) lp->target = xstrdup(Tdest); else lp->target = NULL; return(NULL); } /* * Send a hardlink */ static int sendhardlink(opt_t opts, struct linkbuf *lp, char *rname, int destdir) { static char buff[MAXPATHLEN]; char *lname; /* name of file to link to */ char ername[MAXPATHLEN*4], elname[MAXPATHLEN*4]; debugmsg(DM_MISC, "sendhardlink: rname='%s' pathname='%s' src='%s' target='%s'\n", rname, lp->pathname ? lp->pathname : "", lp->src ? lp->src : "", lp->target ? lp->target : ""); if (lp->target == NULL) lname = lp->pathname; else { lname = buff; strlcpy(lname, remfilename(lp->src, lp->target, lp->pathname, rname, destdir), sizeof(buff)); debugmsg(DM_MISC, "sendhardlink: lname=%s\n", lname); } ENCODE(elname, lname); ENCODE(ername, rname); (void) sendcmd(C_RECVHARDLINK, "%o %s %s", opts, elname, ername); return(response()); } /* * Send a file */ static int sendfile(char *rname, opt_t opts, struct stat *stb, char *user, char *group, int destdir) { int goterr, f; off_t i; char ername[MAXPATHLEN*4]; if (stb->st_nlink > 1) { struct linkbuf *lp; if ((lp = linkinfo(stb)) != NULL) return(sendhardlink(opts, lp, rname, destdir)); } if ((f = open(target, O_RDONLY)) < 0) { error("%s: open for read failed: %s", target, SYSERR); return(-1); } /* * Send file info */ ENCODE(ername, rname); (void) sendcmd(C_RECVREG, "%o %04o %ld %ld %ld %s %s %s", opts, stb->st_mode & 07777, (long) stb->st_size, stb->st_mtime, stb->st_atime, user, group, ername); if (response() < 0) { (void) close(f); return(-1); } debugmsg(DM_MISC, "Send file '%s' %ld bytes\n", rname, (long) stb->st_size); /* * Set remote time out alarm handler. */ (void) signal(SIGALRM, sighandler); /* * Actually transfer the file */ goterr = 0; for (i = 0; i < stb->st_size; i += BUFSIZ) { off_t amt = BUFSIZ; (void) alarm(rtimeout); if (i + amt > stb->st_size) amt = stb->st_size - i; if (read(f, buf, (size_t) amt) != (ssize_t) amt) { error("%s: File changed size", target); err(); ++goterr; /* * XXX - We have to keep going because the * server expects to receive a fixed number * of bytes that we specified as the file size. * We need Out Of Band communication to handle * this situation gracefully. */ } if (xwrite(rem_w, buf, (size_t) amt) < 0) { error("%s: Error writing to client: %s", target, SYSERR); err(); ++goterr; break; } (void) alarm(0); } (void) alarm(0); /* Insure alarm is off */ (void) close(f); debugmsg(DM_MISC, "Send file '%s' %s.\n", (goterr) ? "failed" : "complete", rname); /* * Check for errors and end send */ if (goterr) return(-1); else { ack(); f = response(); if (f < 0) return(-1); else if (f == 0 && IS_ON(opts, DO_COMPARE)) return(0); runspecial(target, opts, rname, destdir); addcmdspecialfile(target, rname, destdir); return(0); } } /* * Check for files on the machine being updated that are not on the master * machine and remove them. * * Return < 0 on error. * Return 0 if nothing happened. * Return > 0 if anything is updated. */ static int rmchk(opt_t opts) { u_char *s; struct stat stb; int didupdate = 0; int n; char targ[MAXPATHLEN*4]; debugmsg(DM_CALL, "rmchk()\n"); /* * Tell the remote to clean the files from the last directory sent. */ (void) sendcmd(C_CLEAN, "%o", IS_ON(opts, DO_VERIFY)); if (response() < 0) return(-1); for ( ; ; ) { n = remline(s = respbuff, sizeof(respbuff), TRUE); if (n <= 0) { error("rmchk: unexpected control record"); return(didupdate); } switch (*s++) { case CC_QUERY: /* Query if file should be removed */ /* * Return the following codes to remove query. * CC_NO -- file exists - DON'T remove. * CC_YES -- file doesn't exist - REMOVE. */ if (DECODE(targ, (char *) s) == -1) { error("rmchk: cannot decode file"); return(-1); } (void) snprintf(ptarget, sizeof(target) - (ptarget - target), "%s%s", (ptarget[-1] == '/' ? "" : "/"), targ); debugmsg(DM_MISC, "check %s\n", target); if (except(target)) (void) sendcmd(CC_NO, NULL); else if (lstat(target, &stb) < 0) { if (sendcmd(CC_YES, NULL) == 0) didupdate = 1; } else (void) sendcmd(CC_NO, NULL); break; case CC_END: *ptarget = CNULL; ack(); return(didupdate); case C_LOGMSG: if (n > 0) message(MT_INFO, "%s", s); break; case C_NOTEMSG: if (n > 0) message(MT_NOTICE, "%s", s); break; /* Goto top of loop */ case C_ERRMSG: message(MT_NERROR, "%s", s); return(didupdate); case C_FERRMSG: message(MT_FERROR, "%s", s); finish(); default: error("rmchk: unexpected response '%s'", respbuff); err(); } } /*NOTREACHED*/ } /* * Send a directory * * Return < 0 on error. * Return 0 if nothing happened. * Return > 0 if anything is updated. */ static int senddir(char *rname, opt_t opts, struct stat *stb, char *user, char *group, int destdir) { DIRENTRY *dp; DIR *d; char *optarget, *cp; int len; int didupdate = 0; char ername[MAXPATHLEN*4]; /* * Send recvdir command in recvit() format. */ ENCODE(ername, rname); (void) sendcmd(C_RECVDIR, "%o %04o 0 0 0 %s %s %s", opts, stb->st_mode & 07777, user, group, ername); if (response() < 0) return(-1); /* * Don't descend into directory */ if (IS_ON(opts, DO_NODESCEND)) return(0); if (IS_ON(opts, DO_REMOVE)) if (rmchk(opts) > 0) ++didupdate; if ((d = opendir(target)) == NULL) { error("%s: opendir failed: %s", target, SYSERR); return(-1); } optarget = ptarget; len = ptarget - target; while ((dp = readdir(d)) != NULL) { if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) continue; if (len + 1 + (int) strlen(dp->d_name) >= MAXPATHLEN - 1) { error("%s/%s: Name too long", target, dp->d_name); continue; } ptarget = optarget; if (ptarget[-1] != '/') *ptarget++ = '/'; cp = dp->d_name; while ((*ptarget++ = *cp++) != '\0') continue; ptarget--; if (sendit(dp->d_name, opts, destdir) > 0) didupdate = 1; } (void) closedir(d); (void) sendcmd(C_END, NULL); (void) response(); ptarget = optarget; *ptarget = CNULL; return(didupdate); } /* * Send a link */ static int sendlink(char *rname, opt_t opts, struct stat *stb, char *user, char *group, int destdir) { int f, n; static char tbuf[BUFSIZ]; char lbuf[MAXPATHLEN]; u_char *s; char ername[MAXPATHLEN*4]; debugmsg(DM_CALL, "sendlink(%s, %x, stb, %d)\n", rname, opts, destdir); if (stb->st_nlink > 1) { struct linkbuf *lp; if ((lp = linkinfo(stb)) != NULL) return(sendhardlink(opts, lp, rname, destdir)); } /* * Gather and send basic link info */ ENCODE(ername, rname); (void) sendcmd(C_RECVSYMLINK, "%o %04o %ld %ld %ld %s %s %s", opts, stb->st_mode & 07777, (long) stb->st_size, stb->st_mtime, stb->st_atime, user, group, ername); if (response() < 0) return(-1); /* * Gather and send additional link info */ if ((n = readlink(target, lbuf, sizeof(lbuf)-1)) != -1) lbuf[n] = '\0'; else { error("%s: readlink failed", target); err(); } (void) snprintf(tbuf, sizeof(tbuf), "%.*s", (int) stb->st_size, lbuf); ENCODE(ername, tbuf); (void) sendcmd(C_NONE, "%s\n", ername); if (n != stb->st_size) { error("%s: file changed size", target); err(); } else ack(); /* * Check response */ f = response(); if (f < 0) return(-1); else if (f == 0 && IS_ON(opts, DO_COMPARE)) return(0); /* * Read and process responses from server. * The server may send multiple messages regarding * file deletes if the remote target is a directory. */ for (;;) { n = remline(s = respbuff, sizeof(respbuff), TRUE); if (n == -1) /* normal EOF */ return(0); if (n == 0) { error("expected control record"); continue; } switch (*s++) { case C_END: /* End of send operation */ *ptarget = CNULL; ack(); runspecial(target, opts, rname, destdir); addcmdspecialfile(target, rname, destdir); return(0); case C_LOGMSG: if (n > 0) message(MT_INFO, "%s", s); break; case C_NOTEMSG: if (n > 0) message(MT_NOTICE, "%s", s); break; /* Goto top of loop */ case C_ERRMSG: message(MT_NERROR, "%s", s); return(-1); case C_FERRMSG: message(MT_FERROR, "%s", s); finish(); default: error("install link: unexpected response '%s'", respbuff); err(); } } /*NOTREACHED*/ } /* * Check to see if file needs to be updated on the remote machine. * Returns: * US_NOTHING - no update * US_NOENT - remote doesn't exist * US_OUTDATE - out of date * US_DOCOMP - comparing binaries to determine if out of date * US_CHMOG - File modes or ownership do not match */ static int update(char *rname, opt_t opts, struct stat *statp) { off_t size; time_t mtime; unsigned short lmode; unsigned short rmode; char *owner = NULL, *group = NULL; int done, n; u_char *cp; char ername[MAXPATHLEN*4]; debugmsg(DM_CALL, "update(%s, 0x%x, 0x%x)\n", rname, opts, statp); switch (statp->st_mode & S_IFMT) { case S_IFBLK: debugmsg(DM_MISC, "%s is a block special; skipping\n", target); return(US_NOTHING); case S_IFCHR: debugmsg(DM_MISC, "%s is a character special; skipping\n", target); return(US_NOTHING); case S_IFIFO: debugmsg(DM_MISC, "%s is a fifo; skipping\n", target); return(US_NOTHING); case S_IFSOCK: debugmsg(DM_MISC, "%s is a socket; skipping\n", target); return(US_NOTHING); } if (IS_ON(opts, DO_NOEXEC)) if (isexec(target, statp)) { debugmsg(DM_MISC, "%s is an executable\n", target); return(US_NOTHING); } /* * Check to see if the file exists on the remote machine. */ ENCODE(ername, rname); (void) sendcmd(C_QUERY, "%s", ername); for (done = 0; !done;) { n = remline(cp = respbuff, sizeof(respbuff), TRUE); if (n <= 0) { error("update: unexpected control record in response to query"); return(US_NOTHING); } switch (*cp++) { case QC_ONNFS: /* Resides on a NFS */ debugmsg(DM_MISC, "update: %s is on a NFS. Skipping...\n", rname); return(US_NOTHING); case QC_SYM: /* Is a symbolic link */ debugmsg(DM_MISC, "update: %s is a symlink. Skipping...\n", rname); return(US_NOTHING); case QC_ONRO: /* Resides on a Read-Only fs */ debugmsg(DM_MISC, "update: %s is on a RO fs. Skipping...\n", rname); return(US_NOTHING); case QC_YES: done = 1; break; case QC_NO: /* file doesn't exist so install it */ return(US_NOENT); case C_ERRMSG: if (cp) message(MT_NERROR, "%s", cp); return(US_NOTHING); case C_FERRMSG: if (cp) message(MT_FERROR, "%s", cp); finish(); case C_NOTEMSG: if (cp) message(MT_NOTICE, "%s", cp); break; /* Goto top of loop */ default: error("update: unexpected response to query '%s'", respbuff); return(US_NOTHING); } } /* * Target exists, but no other info passed */ if (n <= 1 || !S_ISREG(statp->st_mode)) return(US_OUTDATE); if (IS_ON(opts, DO_COMPARE)) return(US_DOCOMP); /* * Parse size */ size = (off_t) strtol(cp, (char **)&cp, 10); if (*cp++ != ' ') { error("update: size not delimited"); return(US_NOTHING); } /* * Parse mtime */ mtime = strtol(cp, (char **)&cp, 10); if (*cp++ != ' ') { error("update: mtime not delimited"); return(US_NOTHING); } /* * Parse remote file mode */ rmode = strtol(cp, (char **)&cp, 8); if (cp && *cp) ++cp; /* * Be backwards compatible */ if (cp && *cp != CNULL) { /* * Parse remote file owner */ owner = strtok((char *)cp, " "); if (owner == NULL) { error("update: owner not delimited"); return(US_NOTHING); } /* * Parse remote file group */ group = strtok(NULL, " "); if (group == NULL) { error("update: group not delimited"); return(US_NOTHING); } } /* * File needs to be updated? */ lmode = statp->st_mode & 07777; debugmsg(DM_MISC, "update(%s,) local mode %04o remote mode %04o\n", rname, lmode, rmode); debugmsg(DM_MISC, "update(%s,) size %ld mtime %d owner '%s' grp '%s'\n", rname, (long) size, mtime, owner, group); if (statp->st_mtime != mtime) { if (statp->st_mtime < mtime && IS_ON(opts, DO_YOUNGER)) { message(MT_WARNING, "%s: Warning: remote copy is newer", target); return(US_NOTHING); } return(US_OUTDATE); } if (statp->st_size != size) { debugmsg(DM_MISC, "size does not match (%ld != %ld).\n", (long) statp->st_size, (long) size); return(US_OUTDATE); } if (!IS_ON(opts, DO_NOCHKMODE) && lmode != rmode) { debugmsg(DM_MISC, "modes do not match (%04o != %04o).\n", lmode, rmode); return(US_CHMOG); } /* * Check ownership */ if (!IS_ON(opts, DO_NOCHKOWNER) && owner) { if (!IS_ON(opts, DO_NUMCHKOWNER)) { /* Check by string compare */ if (strcmp(owner, getusername(statp->st_uid, target, opts)) != 0) { debugmsg(DM_MISC, "owner does not match (%s != %s).\n", getusername(statp->st_uid, target, opts), owner); return(US_CHMOG); } } else { /* * Check numerically. * Allow negative numbers. */ while (*owner && !isdigit((unsigned char)*owner) && (*owner != '-')) ++owner; if (owner && (UID_T) atoi(owner) != statp->st_uid) { debugmsg(DM_MISC, "owner does not match (%d != %s).\n", statp->st_uid, owner); return(US_CHMOG); } } } if (!IS_ON(opts, DO_NOCHKGROUP) && group) { if (!IS_ON(opts, DO_NUMCHKGROUP)) { /* Check by string compare */ if (strcmp(group, getgroupname(statp->st_gid, target, opts)) != 0) { debugmsg(DM_MISC, "group does not match (%s != %s).\n", getgroupname(statp->st_gid, target, opts), group); return(US_CHMOG); } } else { /* Check numerically */ /* Allow negative gid */ while (*group && !isdigit((unsigned char) *group) && (*group != '-')) ++group; if (group && (UID_T) atoi(group) != statp->st_gid) { debugmsg(DM_MISC, "group does not match (%d != %s).\n", statp->st_gid, group); return(US_CHMOG); } } } return(US_NOTHING); } /* * Stat a file */ static int dostat(char *file, struct stat *statbuf, opt_t opts) { int s; if (IS_ON(opts, DO_FOLLOW)) s = stat(file, statbuf); else s = lstat(file, statbuf); if (s < 0) error("%s: %s failed: %s", file, IS_ON(opts, DO_FOLLOW) ? "stat" : "lstat", SYSERR); return(s); } /* * We need to just change file info. */ static int statupdate(int u, char *target, opt_t opts, char *rname, int destdir, struct stat *st, char *user, char *group) { int rv = 0; char ername[MAXPATHLEN*4]; int lmode = st->st_mode & 07777; if (u == US_CHMOG) { if (IS_ON(opts, DO_VERIFY)) { message(MT_INFO, "%s: need to change to perm %04o, owner %s, group %s", target, lmode, user, group); runspecial(target, opts, rname, destdir); } else { message(MT_CHANGE, "%s: change to perm %04o, owner %s, group %s", target, lmode, user, group); ENCODE(ername, rname); (void) sendcmd(C_CHMOG, "%o %04o %s %s %s", opts, lmode, user, group, ername); (void) response(); } rv = 1; } return(rv); } /* * We need to install/update: */ static int fullupdate(int u, char *target, opt_t opts, char *rname, int destdir, struct stat *st, char *user, char *group) { /* * No entry - need to install */ if (u == US_NOENT) { if (IS_ON(opts, DO_VERIFY)) { message(MT_INFO, "%s: need to install", target); runspecial(target, opts, rname, destdir); return(1); } if (!IS_ON(opts, DO_QUIET)) message(MT_CHANGE, "%s: installing", target); FLAG_OFF(opts, (DO_COMPARE|DO_REMOVE)); } /* * Handle special file types, including directories and symlinks */ if (S_ISDIR(st->st_mode)) { if (senddir(rname, opts, st, user, group, destdir) > 0) return(1); return(0); } else if (S_ISLNK(st->st_mode)) { if (u == US_NOENT) FLAG_ON(opts, DO_COMPARE); /* * Since we always send link info to the server * so the server can determine if the remote link * is correct, we never get any acknowledgement * from the server whether the link was really * updated or not. */ (void) sendlink(rname, opts, st, user, group, destdir); return(0); } else if (S_ISREG(st->st_mode)) { if (u == US_OUTDATE) { if (IS_ON(opts, DO_VERIFY)) { message(MT_INFO, "%s: need to update", target); runspecial(target, opts, rname, destdir); return(1); } if (!IS_ON(opts, DO_QUIET)) message(MT_CHANGE, "%s: updating", target); } return (sendfile(rname, opts, st, user, group, destdir) == 0); } else { message(MT_INFO, "%s: unknown file type 0%o", target, st->st_mode); return(0); } } /* * Transfer the file or directory in target[]. * rname is the name of the file on the remote host. * * Return < 0 on error. * Return 0 if nothing happened. * Return > 0 if anything is updated. */ static int sendit(char *rname, opt_t opts, int destdir) { static struct stat stb; char *user, *group; int u, len; /* * Remove possible accidental newline */ len = strlen(rname); if (len > 0 && rname[len-1] == '\n') rname[len-1] = CNULL; if (checkfilename(rname) != 0) return(-1); debugmsg(DM_CALL, "sendit(%s, 0x%x) called\n", rname, opts); if (except(target)) return(0); if (dostat(target, &stb, opts) < 0) return(-1); /* * Does rname need updating? */ u = update(rname, opts, &stb); debugmsg(DM_MISC, "sendit(%s, 0x%x): update status of %s is %d\n", rname, opts, target, u); /* * Don't need to update the file, but we may need to save hardlink * info. */ if (u == US_NOTHING) { if (S_ISREG(stb.st_mode) && stb.st_nlink > 1) (void) linkinfo(&stb); return(0); } user = getusername(stb.st_uid, target, opts); group = getgroupname(stb.st_gid, target, opts); if (u == US_CHMOG && IS_OFF(opts, DO_UPDATEPERM)) u = US_OUTDATE; if (u == US_NOENT || u == US_OUTDATE || u == US_DOCOMP) return(fullupdate(u, target, opts, rname, destdir, &stb, user, group)); if (u == US_CHMOG) return(statupdate(u, target, opts, rname, destdir, &stb, user, group)); return(0); } /* * Remove temporary files and do any cleanup operations before exiting. */ void cleanup(int dummy) { char *file; #ifdef USE_STATDB extern char statfile[]; (void) unlink(statfile); #endif if ((file = getnotifyfile()) != NULL) (void) unlink(file); } /* * Update the file(s) if they are different. * destdir = 1 if destination should be a directory * (i.e., more than one source is being copied to the same destination). * * Return < 0 on error. * Return 0 if nothing updated. * Return > 0 if something was updated. */ int install(char *src, char *dest, int ddir, int destdir, opt_t opts) { static char destcopy[MAXPATHLEN]; char *rname; int didupdate = 0; char ername[MAXPATHLEN*4]; debugmsg(DM_CALL, "install(src=%s,dest=%s,ddir=%d,destdir=%d,opts=%d) start\n", (src?src:"NULL"), (dest?dest:"NULL"), ddir, destdir, opts); /* * Save source name */ if (IS_ON(opts, DO_WHOLE)) source[0] = CNULL; else (void) strlcpy(source, src, sizeof(source)); if (dest == NULL) { FLAG_OFF(opts, DO_WHOLE); /* WHOLE only useful if renaming */ dest = src; } if (checkfilename(dest) != 0) return(-1); if (nflag || debug) { static char buff[BUFSIZ]; char *cp; cp = getondistoptlist(opts); (void) snprintf(buff, sizeof(buff), "%s%s%s %s %s", IS_ON(opts, DO_VERIFY) ? "verify" : "install", (cp) ? " -o" : "", (cp) ? cp : "", src, dest); if (nflag) { printf("%s\n", buff); return(0); } else debugmsg(DM_MISC, "%s\n", buff); } rname = exptilde(target, src, sizeof(target)); if (rname == NULL) return(-1); ptarget = target; while (*ptarget) ptarget++; /* * If we are renaming a directory and we want to preserve * the directory hierarchy (-w), we must strip off the leading * directory name and preserve the rest. */ if (IS_ON(opts, DO_WHOLE)) { while (*rname == '/') rname++; ddir = 1; destdir = 1; } else { rname = strrchr(target, '/'); /* Check if no '/' or target ends in '/' */ if (rname == NULL || rname+1 == NULL || *(rname+1) == CNULL) rname = target; else rname++; } debugmsg(DM_MISC, "install: target=%s src=%s rname=%s dest='%s' destdir=%d, ddir=%d\n", target, source, rname, dest, destdir, ddir); /* * Pass the destination file/directory name to remote. */ ENCODE(ername, dest); if (ddir) (void) sendcmd(C_DIRTARGET, "%o %s", opts, ername); else (void) sendcmd(C_TARGET, "%o %s", opts, ername); if (response() < 0) return(-1); /* * Save the name of the remote target destination if we are * in WHOLE mode (destdir > 0) or if the source and destination * are not the same. This info will be used later for maintaining * hardlink info. */ if (destdir || (src && dest && strcmp(src, dest))) { (void) strlcpy(destcopy, dest, sizeof(destcopy)); Tdest = destcopy; } didupdate = sendit(rname, opts, destdir); Tdest = 0; return(didupdate); }