- WARNS ?= 6 clean
[dragonfly.git] / usr.bin / touch / touch.c
1 /*
2  * Copyright (c) 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#) Copyright (c) 1993 The Regents of the University of California.  All rights reserved.
34  * @(#)touch.c  8.1 (Berkeley) 6/6/93
35  * $FreeBSD: src/usr.bin/touch/touch.c,v 1.11.2.2 2002/07/28 06:52:15 eric Exp $
36  * $DragonFly: src/usr.bin/touch/touch.c,v 1.4 2004/08/15 15:06:58 joerg Exp $
37  */
38
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <sys/time.h>
42
43 #include <err.h>
44 #include <errno.h>
45 #include <fcntl.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <time.h>
50 #include <unistd.h>
51
52 static int      rw(const char *, const struct stat *, int);
53 static void     stime_arg1(const char *, struct timeval *);
54 static void     stime_arg2(const char *, int, struct timeval *);
55 static void     stime_file(const char *, struct timeval *);
56 static void     usage(void);
57
58 int
59 main(int argc, char **argv)
60 {
61         struct stat sb;
62         struct timeval tv[2];
63         int aflag, cflag, fflag, mflag, ch, fd, len, rval, timeset;
64         char *p;
65
66         aflag = cflag = fflag = mflag = timeset = 0;
67         if (gettimeofday(&tv[0], NULL) == -1)
68                 err(1, "gettimeofday");
69
70         while ((ch = getopt(argc, argv, "acfmr:t:")) != -1)
71                 switch(ch) {
72                 case 'a':
73                         aflag = 1;
74                         break;
75                 case 'c':
76                         cflag = 1;
77                         break;
78                 case 'f':
79                         fflag = 1;
80                         break;
81                 case 'm':
82                         mflag = 1;
83                         break;
84                 case 'r':
85                         timeset = 1;
86                         stime_file(optarg, tv);
87                         break;
88                 case 't':
89                         timeset = 1;
90                         stime_arg1(optarg, tv);
91                         break;
92                 default:
93                         usage();
94                 }
95         argc -= optind;
96         argv += optind;
97
98         /* Default is both -a and -m. */
99         if (aflag == 0 && mflag == 0)
100                 aflag = mflag = 1;
101
102         /*
103          * If no -r or -t flag, at least two operands, the first of which
104          * is an 8 or 10 digit number, use the obsolete time specification.
105          */
106         if (!timeset && argc > 1) {
107                 strtol(argv[0], &p, 10);
108                 len = p - argv[0];
109                 if (*p == '\0' && (len == 8 || len == 10)) {
110                         timeset = 1;
111                         stime_arg2(*argv++, len == 10, tv);
112                 }
113         }
114
115         /* Otherwise use the current time of day. */
116         if (!timeset)
117                 tv[1] = tv[0];
118
119         if (*argv == NULL)
120                 usage();
121
122         for (rval = 0; *argv; ++argv) {
123                 /* See if the file exists. */
124                 if (stat(*argv, &sb)) {
125                         if (!cflag) {
126                                 /* Create the file. */
127                                 fd = open(*argv,
128                                     O_WRONLY | O_CREAT, DEFFILEMODE);
129                                 if (fd == -1 || fstat(fd, &sb) || close(fd)) {
130                                         rval = 1;
131                                         warn("%s", *argv);
132                                         continue;
133                                 }
134
135                                 /* If using the current time, we're done. */
136                                 if (!timeset)
137                                         continue;
138                         } else
139                                 continue;
140                 }
141
142                 if (!aflag)
143                         TIMESPEC_TO_TIMEVAL(&tv[0], &sb.st_atimespec);
144                 if (!mflag)
145                         TIMESPEC_TO_TIMEVAL(&tv[1], &sb.st_mtimespec);
146
147                 /* Try utimes(2). */
148                 if (!utimes(*argv, tv))
149                         continue;
150
151                 /* If the user specified a time, nothing else we can do. */
152                 if (timeset) {
153                         rval = 1;
154                         warn("%s", *argv);
155                 }
156
157                 /*
158                  * System V and POSIX 1003.1 require that a NULL argument
159                  * set the access/modification times to the current time.
160                  * The permission checks are different, too, in that the
161                  * ability to write the file is sufficient.  Take a shot.
162                  */
163                  if (!utimes(*argv, NULL))
164                         continue;
165
166                 /* Try reading/writing. */
167                 if (!S_ISLNK(sb.st_mode) && !S_ISDIR(sb.st_mode) &&
168                     rw(*argv, &sb, fflag))
169                         rval = 1;
170                 else
171                         warn("%s", *argv);
172         }
173         exit(rval);
174 }
175
176 #define ATOI2(ar)       ((ar)[0] - '0') * 10 + ((ar)[1] - '0'); (ar) += 2;
177
178 static void
179 stime_arg1(const char *arg, struct timeval *tvp)
180 {
181         time_t now;
182         struct tm *t;
183         int yearset;
184         char *p;
185                                         /* Start with the current time. */
186         now = tvp[0].tv_sec;
187         if ((t = localtime(&now)) == NULL)
188                 err(1, "localtime");
189                                         /* [[CC]YY]MMDDhhmm[.SS] */
190         if ((p = strchr(arg, '.')) == NULL)
191                 t->tm_sec = 0;          /* Seconds defaults to 0. */
192         else {
193                 if (strlen(p + 1) != 2)
194                         goto failed;
195                 *p++ = '\0';
196                 t->tm_sec = ATOI2(p);
197         }
198
199         yearset = 0;
200         switch(strlen(arg)) {
201         case 12:                        /* CCYYMMDDhhmm */
202                 t->tm_year = ATOI2(arg);
203                 t->tm_year *= 100;
204                 yearset = 1;
205                 /* FALLTHOUGH */
206         case 10:                        /* YYMMDDhhmm */
207                 if (yearset) {
208                         yearset = ATOI2(arg);
209                         t->tm_year += yearset;
210                 } else {
211                         yearset = ATOI2(arg);
212                         if (yearset < 69)
213                                 t->tm_year = yearset + 2000;
214                         else
215                                 t->tm_year = yearset + 1900;
216                 }
217                 t->tm_year -= 1900;     /* Convert to UNIX time. */
218                 /* FALLTHROUGH */
219         case 8:                         /* MMDDhhmm */
220                 t->tm_mon = ATOI2(arg);
221                 --t->tm_mon;            /* Convert from 01-12 to 00-11 */
222                 t->tm_mday = ATOI2(arg);
223                 t->tm_hour = ATOI2(arg);
224                 t->tm_min = ATOI2(arg);
225                 break;
226         default:
227                 goto failed;
228         }
229
230         t->tm_isdst = -1;               /* Figure out DST. */
231         tvp[0].tv_sec = tvp[1].tv_sec = mktime(t);
232         if (tvp[0].tv_sec == -1)
233                 goto failed;
234
235         tvp[0].tv_usec = tvp[1].tv_usec = 0;
236
237 failed:
238         errx(1, "out of range or illegal time specification: [[CC]YY]MMDDhhmm[.SS]");
239 }
240
241 static void
242 stime_arg2(const char *arg, int year, struct timeval *tvp)
243 {
244         time_t now;
245         struct tm *t;
246                                         /* Start with the current time. */
247         now = tvp[0].tv_sec;
248         if ((t = localtime(&now)) == NULL)
249                 err(1, "localtime");
250
251         t->tm_mon = ATOI2(arg);         /* MMDDhhmm[yy] */
252         --t->tm_mon;                    /* Convert from 01-12 to 00-11 */
253         t->tm_mday = ATOI2(arg);
254         t->tm_hour = ATOI2(arg);
255         t->tm_min = ATOI2(arg);
256         if (year) {
257                 t->tm_year = ATOI2(arg);
258                 if (t->tm_year < 39)    /* support 2000-2038 not 1902-1969 */
259                         t->tm_year += 100;
260         }
261
262         t->tm_isdst = -1;               /* Figure out DST. */
263         tvp[0].tv_sec = tvp[1].tv_sec = mktime(t);
264         if (tvp[0].tv_sec == -1)
265                 errx(1, "out of range or illegal time specification: MMDDhhmm[yy]");
266
267         tvp[0].tv_usec = tvp[1].tv_usec = 0;
268 }
269
270 static void
271 stime_file(const char *fname, struct timeval *tvp)
272 {
273         struct stat sb;
274
275         if (stat(fname, &sb))
276                 err(1, "%s", fname);
277         TIMESPEC_TO_TIMEVAL(tvp, &sb.st_atimespec);
278         TIMESPEC_TO_TIMEVAL(tvp + 1, &sb.st_mtimespec);
279 }
280
281 static int
282 rw(const char *fname, const struct stat *sbp, int force)
283 {
284         int fd, needed_chmod;
285         u_char byte;
286         const char *warn_msg = "%s";
287
288         /* Try regular files. */
289         if (!S_ISREG(sbp->st_mode)) {
290                 warnx("%s: %s", fname, strerror(EFTYPE));
291                 return (1);
292         }
293
294         needed_chmod = 0;
295         if ((fd = open(fname, O_RDWR, 0)) == -1) {
296                 if (!force || chmod(fname, DEFFILEMODE))
297                         goto failed;
298                 if ((fd = open(fname, O_RDWR, 0)) == -1)
299                         goto failed;
300                 needed_chmod = 1;
301         }
302
303         if (sbp->st_size != 0) {
304                 if (read(fd, &byte, sizeof(byte)) != sizeof(byte))
305                         goto failed;
306                 if (lseek(fd, (off_t)0, SEEK_SET) == -1)
307                         goto failed;
308                 if (write(fd, &byte, sizeof(byte)) != sizeof(byte))
309                         goto failed;
310         } else {
311                 if (write(fd, &byte, sizeof(byte)) != sizeof(byte))
312                         goto failed;
313                 if (ftruncate(fd, (off_t)0)) {
314                         warn_msg = "%s: file modified";
315                         goto failed;
316                 }
317         }
318
319         if (close(fd))
320                 goto failed;
321         if (needed_chmod && chmod(fname, sbp->st_mode)) {
322                 warn_msg = "%s: permissions modified";
323                 goto failed;
324         }
325         return(0);
326
327 failed:
328         warn("%s", warn_msg);
329         return(1);
330 }
331
332 static void
333 usage(void)
334 {
335         fprintf(stderr, "usage: touch [-acfm] [-r file] [-t [[CC]YY]MMDDhhmm[.SS]] file ...\n");
336         exit(1);
337 }