Sync tnftp with NetBSD:
[dragonfly.git] / contrib / tnftp / util.c
1 /*      $NetBSD: util.c,v 1.144 2007/12/05 03:46:34 lukem Exp $ */
2
3 /*-
4  * Copyright (c) 1997-2007 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Luke Mewburn.
9  *
10  * This code is derived from software contributed to The NetBSD Foundation
11  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
12  * NASA Ames Research Center.
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions
16  * are met:
17  * 1. Redistributions of source code must retain the above copyright
18  *    notice, this list of conditions and the following disclaimer.
19  * 2. Redistributions in binary form must reproduce the above copyright
20  *    notice, this list of conditions and the following disclaimer in the
21  *    documentation and/or other materials provided with the distribution.
22  * 3. All advertising materials mentioning features or use of this software
23  *    must display the following acknowledgement:
24  *      This product includes software developed by the NetBSD
25  *      Foundation, Inc. and its contributors.
26  * 4. Neither the name of The NetBSD Foundation nor the names of its
27  *    contributors may be used to endorse or promote products derived
28  *    from this software without specific prior written permission.
29  *
30  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
31  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
32  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
33  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
34  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
37  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
38  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40  * POSSIBILITY OF SUCH DAMAGE.
41  */
42
43 /*
44  * Copyright (c) 1985, 1989, 1993, 1994
45  *      The Regents of the University of California.  All rights reserved.
46  *
47  * Redistribution and use in source and binary forms, with or without
48  * modification, are permitted provided that the following conditions
49  * are met:
50  * 1. Redistributions of source code must retain the above copyright
51  *    notice, this list of conditions and the following disclaimer.
52  * 2. Redistributions in binary form must reproduce the above copyright
53  *    notice, this list of conditions and the following disclaimer in the
54  *    documentation and/or other materials provided with the distribution.
55  * 3. Neither the name of the University nor the names of its contributors
56  *    may be used to endorse or promote products derived from this software
57  *    without specific prior written permission.
58  *
59  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69  * SUCH DAMAGE.
70  */
71
72 #include <sys/cdefs.h>
73 #ifndef lint
74 __RCSID("$NetBSD: util.c,v 1.144 2007/12/05 03:46:34 lukem Exp $");
75 #endif /* not lint */
76
77 /*
78  * FTP User Program -- Misc support routines
79  */
80 #include <sys/param.h>
81 #include <sys/socket.h>
82 #include <sys/ioctl.h>
83 #include <sys/time.h>
84 #include <netinet/in.h>
85 #include <arpa/ftp.h>
86
87 #include <ctype.h>
88 #include <err.h>
89 #include <errno.h>
90 #include <fcntl.h>
91 #include <glob.h>
92 #include <signal.h>
93 #include <libgen.h>
94 #include <limits.h>
95 #include <netdb.h>
96 #include <stdio.h>
97 #include <stdlib.h>
98 #include <string.h>
99 #include <termios.h>
100 #include <time.h>
101 #include <tzfile.h>
102 #include <unistd.h>
103
104 #include "ftp_var.h"
105
106 /*
107  * Connect to peer server and auto-login, if possible.
108  */
109 void
110 setpeer(int argc, char *argv[])
111 {
112         char *host;
113         char *port;
114
115         if (argc == 0)
116                 goto usage;
117         if (connected) {
118                 fprintf(ttyout, "Already connected to %s, use close first.\n",
119                     hostname);
120                 code = -1;
121                 return;
122         }
123         if (argc < 2)
124                 (void)another(&argc, &argv, "to");
125         if (argc < 2 || argc > 3) {
126  usage:
127                 UPRINTF("usage: %s host-name [port]\n", argv[0]);
128                 code = -1;
129                 return;
130         }
131         if (gatemode)
132                 port = gateport;
133         else
134                 port = ftpport;
135         if (argc > 2)
136                 port = argv[2];
137
138         if (gatemode) {
139                 if (gateserver == NULL || *gateserver == '\0')
140                         errx(1, "main: gateserver not defined");
141                 host = hookup(gateserver, port);
142         } else
143                 host = hookup(argv[1], port);
144
145         if (host) {
146                 if (gatemode && verbose) {
147                         fprintf(ttyout,
148                             "Connecting via pass-through server %s\n",
149                             gateserver);
150                 }
151
152                 connected = 1;
153                 /*
154                  * Set up defaults for FTP.
155                  */
156                 (void)strlcpy(typename, "ascii", sizeof(typename));
157                 type = TYPE_A;
158                 curtype = TYPE_A;
159                 (void)strlcpy(formname, "non-print", sizeof(formname));
160                 form = FORM_N;
161                 (void)strlcpy(modename, "stream", sizeof(modename));
162                 mode = MODE_S;
163                 (void)strlcpy(structname, "file", sizeof(structname));
164                 stru = STRU_F;
165                 (void)strlcpy(bytename, "8", sizeof(bytename));
166                 bytesize = 8;
167                 if (autologin)
168                         (void)ftp_login(argv[1], NULL, NULL);
169         }
170 }
171
172 static void
173 parse_feat(const char *line)
174 {
175
176                         /*
177                          * work-around broken ProFTPd servers that can't
178                          * even obey RFC2389.
179                          */
180         while (*line && isspace((int)*line))
181                 line++;
182
183         if (strcasecmp(line, "MDTM") == 0)
184                 features[FEAT_MDTM] = 1;
185         else if (strncasecmp(line, "MLST", sizeof("MLST") - 1) == 0) {
186                 features[FEAT_MLST] = 1;
187         } else if (strcasecmp(line, "REST STREAM") == 0)
188                 features[FEAT_REST_STREAM] = 1;
189         else if (strcasecmp(line, "SIZE") == 0)
190                 features[FEAT_SIZE] = 1;
191         else if (strcasecmp(line, "TVFS") == 0)
192                 features[FEAT_TVFS] = 1;
193 }
194
195 /*
196  * Determine the remote system type (SYST) and features (FEAT).
197  * Call after a successful login (i.e, connected = -1)
198  */
199 void
200 getremoteinfo(void)
201 {
202         int overbose, i;
203
204         overbose = verbose;
205         if (ftp_debug == 0)
206                 verbose = -1;
207
208                         /* determine remote system type */
209         if (command("SYST") == COMPLETE) {
210                 if (overbose) {
211                         char *cp, c;
212
213                         c = 0;
214                         cp = strchr(reply_string + 4, ' ');
215                         if (cp == NULL)
216                                 cp = strchr(reply_string + 4, '\r');
217                         if (cp) {
218                                 if (cp[-1] == '.')
219                                         cp--;
220                                 c = *cp;
221                                 *cp = '\0';
222                         }
223
224                         fprintf(ttyout, "Remote system type is %s.\n",
225                             reply_string + 4);
226                         if (cp)
227                                 *cp = c;
228                 }
229                 if (!strncmp(reply_string, "215 UNIX Type: L8", 17)) {
230                         if (proxy)
231                                 unix_proxy = 1;
232                         else
233                                 unix_server = 1;
234                         /*
235                          * Set type to 0 (not specified by user),
236                          * meaning binary by default, but don't bother
237                          * telling server.  We can use binary
238                          * for text files unless changed by the user.
239                          */
240                         type = 0;
241                         (void)strlcpy(typename, "binary", sizeof(typename));
242                         if (overbose)
243                             fprintf(ttyout,
244                                 "Using %s mode to transfer files.\n",
245                                 typename);
246                 } else {
247                         if (proxy)
248                                 unix_proxy = 0;
249                         else
250                                 unix_server = 0;
251                         if (overbose &&
252                             !strncmp(reply_string, "215 TOPS20", 10))
253                                 fputs(
254 "Remember to set tenex mode when transferring binary files from this machine.\n",
255                                     ttyout);
256                 }
257         }
258
259                         /* determine features (if any) */
260         for (i = 0; i < FEAT_max; i++)
261                 features[i] = -1;
262         reply_callback = parse_feat;
263         if (command("FEAT") == COMPLETE) {
264                 for (i = 0; i < FEAT_max; i++) {
265                         if (features[i] == -1)
266                                 features[i] = 0;
267                 }
268                 features[FEAT_FEAT] = 1;
269         } else
270                 features[FEAT_FEAT] = 0;
271 #ifndef NO_DEBUG
272         if (ftp_debug) {
273 #define DEBUG_FEAT(x) fprintf(ttyout, "features[" #x "] = %d\n", features[(x)])
274                 DEBUG_FEAT(FEAT_FEAT);
275                 DEBUG_FEAT(FEAT_MDTM);
276                 DEBUG_FEAT(FEAT_MLST);
277                 DEBUG_FEAT(FEAT_REST_STREAM);
278                 DEBUG_FEAT(FEAT_SIZE);
279                 DEBUG_FEAT(FEAT_TVFS);
280 #undef DEBUG_FEAT
281         }
282 #endif
283         reply_callback = NULL;
284
285         verbose = overbose;
286 }
287
288 /*
289  * Reset the various variables that indicate connection state back to
290  * disconnected settings.
291  * The caller is responsible for issuing any commands to the remote server
292  * to perform a clean shutdown before this is invoked.
293  */
294 void
295 cleanuppeer(void)
296 {
297
298         if (cout)
299                 (void)fclose(cout);
300         cout = NULL;
301         connected = 0;
302         unix_server = 0;
303         unix_proxy = 0;
304                         /*
305                          * determine if anonftp was specifically set with -a
306                          * (1), or implicitly set by auto_fetch() (2). in the
307                          * latter case, disable after the current xfer
308                          */
309         if (anonftp == 2)
310                 anonftp = 0;
311         data = -1;
312         epsv4bad = 0;
313         if (username)
314                 free(username);
315         username = NULL;
316         if (!proxy)
317                 macnum = 0;
318 }
319
320 /*
321  * Top-level signal handler for interrupted commands.
322  */
323 void
324 intr(int signo)
325 {
326
327         sigint_raised = 1;
328         alarmtimer(0);
329         if (fromatty)
330                 write(fileno(ttyout), "\n", 1);
331         siglongjmp(toplevel, 1);
332 }
333
334 /*
335  * Signal handler for lost connections; cleanup various elements of
336  * the connection state, and call cleanuppeer() to finish it off.
337  */
338 void
339 lostpeer(int dummy)
340 {
341         int oerrno = errno;
342
343         alarmtimer(0);
344         if (connected) {
345                 if (cout != NULL) {
346                         (void)shutdown(fileno(cout), 1+1);
347                         (void)fclose(cout);
348                         cout = NULL;
349                 }
350                 if (data >= 0) {
351                         (void)shutdown(data, 1+1);
352                         (void)close(data);
353                         data = -1;
354                 }
355                 connected = 0;
356         }
357         pswitch(1);
358         if (connected) {
359                 if (cout != NULL) {
360                         (void)shutdown(fileno(cout), 1+1);
361                         (void)fclose(cout);
362                         cout = NULL;
363                 }
364                 connected = 0;
365         }
366         proxflag = 0;
367         pswitch(0);
368         cleanuppeer();
369         errno = oerrno;
370 }
371
372
373 /*
374  * Login to remote host, using given username & password if supplied.
375  * Return non-zero if successful.
376  */
377 int
378 ftp_login(const char *host, const char *luser, const char *lpass)
379 {
380         char tmp[80];
381         char *user, *pass, *acct, *p;
382         char emptypass[] = "";
383         const char *errormsg;
384         int n, aflag, rval, nlen;
385
386         aflag = rval = 0;
387         user = pass = acct = NULL;
388         if (luser)
389                 user = ftp_strdup(luser);
390         if (lpass)
391                 pass = ftp_strdup(lpass);
392
393         DPRINTF("ftp_login: user `%s' pass `%s' host `%s'\n",
394             STRorNULL(user), STRorNULL(pass), STRorNULL(host));
395
396         /*
397          * Set up arguments for an anonymous FTP session, if necessary.
398          */
399         if (anonftp) {
400                 FREEPTR(user);
401                 user = ftp_strdup("anonymous"); /* as per RFC1635 */
402                 FREEPTR(pass);
403                 pass = ftp_strdup(getoptionvalue("anonpass"));
404         }
405
406         if (ruserpass(host, &user, &pass, &acct) < 0) {
407                 code = -1;
408                 goto cleanup_ftp_login;
409         }
410
411         while (user == NULL) {
412                 if (localname)
413                         fprintf(ttyout, "Name (%s:%s): ", host, localname);
414                 else
415                         fprintf(ttyout, "Name (%s): ", host);
416                 errormsg = NULL;
417                 nlen = getline(stdin, tmp, sizeof(tmp), &errormsg);
418                 if (nlen < 0) {
419                         fprintf(ttyout, "%s; %s aborted.\n", errormsg, "login");
420                         code = -1;
421                         goto cleanup_ftp_login;
422                 } else if (nlen == 0) {
423                         user = ftp_strdup(localname);
424                 } else {
425                         user = ftp_strdup(tmp);
426                 }
427         }
428
429         if (gatemode) {
430                 char *nuser;
431                 size_t len;
432
433                 len = strlen(user) + 1 + strlen(host) + 1;
434                 nuser = ftp_malloc(len);
435                 (void)strlcpy(nuser, user, len);
436                 (void)strlcat(nuser, "@",  len);
437                 (void)strlcat(nuser, host, len);
438                 FREEPTR(user);
439                 user = nuser;
440         }
441
442         n = command("USER %s", user);
443         if (n == CONTINUE) {
444                 if (pass == NULL) {
445                         p = getpass("Password: ");
446                         if (p == NULL)
447                                 p = emptypass;
448                         pass = ftp_strdup(p);
449                         memset(p, 0, strlen(p));
450                 }
451                 n = command("PASS %s", pass);
452                 memset(pass, 0, strlen(pass));
453         }
454         if (n == CONTINUE) {
455                 aflag++;
456                 if (acct == NULL) {
457                         p = getpass("Account: ");
458                         if (p == NULL)
459                                 p = emptypass;
460                         acct = ftp_strdup(p);
461                         memset(p, 0, strlen(p));
462                 }
463                 if (acct[0] == '\0') {
464                         warnx("Login failed");
465                         goto cleanup_ftp_login;
466                 }
467                 n = command("ACCT %s", acct);
468                 memset(acct, 0, strlen(acct));
469         }
470         if ((n != COMPLETE) ||
471             (!aflag && acct != NULL && command("ACCT %s", acct) != COMPLETE)) {
472                 warnx("Login failed");
473                 goto cleanup_ftp_login;
474         }
475         rval = 1;
476         username = ftp_strdup(user);
477         if (proxy)
478                 goto cleanup_ftp_login;
479
480         connected = -1;
481         getremoteinfo();
482         for (n = 0; n < macnum; ++n) {
483                 if (!strcmp("init", macros[n].mac_name)) {
484                         (void)strlcpy(line, "$init", sizeof(line));
485                         makeargv();
486                         domacro(margc, margv);
487                         break;
488                 }
489         }
490         updatelocalcwd();
491         updateremotecwd();
492
493  cleanup_ftp_login:
494         FREEPTR(user);
495         if (pass != NULL)
496                 memset(pass, 0, strlen(pass));
497         FREEPTR(pass);
498         if (acct != NULL)
499                 memset(acct, 0, strlen(acct));
500         FREEPTR(acct);
501         return (rval);
502 }
503
504 /*
505  * `another' gets another argument, and stores the new argc and argv.
506  * It reverts to the top level (via intr()) on EOF/error.
507  *
508  * Returns false if no new arguments have been added.
509  */
510 int
511 another(int *pargc, char ***pargv, const char *prompt)
512 {
513         const char      *errormsg;
514         int             ret, nlen;
515         size_t          len;
516
517         len = strlen(line);
518         if (len >= sizeof(line) - 3) {
519                 fputs("Sorry, arguments too long.\n", ttyout);
520                 intr(0);
521         }
522         fprintf(ttyout, "(%s) ", prompt);
523         line[len++] = ' ';
524         errormsg = NULL;
525         nlen = getline(stdin, line + len, sizeof(line)-len, &errormsg);
526         if (nlen < 0) {
527                 fprintf(ttyout, "%s; %s aborted.\n", errormsg, "operation");
528                 intr(0);
529         }
530         len += nlen;
531         makeargv();
532         ret = margc > *pargc;
533         *pargc = margc;
534         *pargv = margv;
535         return (ret);
536 }
537
538 /*
539  * glob files given in argv[] from the remote server.
540  * if errbuf isn't NULL, store error messages there instead
541  * of writing to the screen.
542  */
543 char *
544 remglob(char *argv[], int doswitch, const char **errbuf)
545 {
546         static char buf[MAXPATHLEN];
547         static FILE *ftemp = NULL;
548         static char **args;
549         char temp[MAXPATHLEN];
550         int oldverbose, oldhash, oldprogress, fd;
551         char *cp;
552         const char *mode;
553         size_t len;
554
555         if (!mflag || !connected) {
556                 if (!doglob)
557                         args = NULL;
558                 else {
559                         if (ftemp) {
560                                 (void)fclose(ftemp);
561                                 ftemp = NULL;
562                         }
563                 }
564                 return (NULL);
565         }
566         if (!doglob) {
567                 if (args == NULL)
568                         args = argv;
569                 if ((cp = *++args) == NULL)
570                         args = NULL;
571                 return (cp);
572         }
573         if (ftemp == NULL) {
574                 len = strlcpy(temp, tmpdir, sizeof(temp));
575                 if (temp[len - 1] != '/')
576                         (void)strlcat(temp, "/", sizeof(temp));
577                 (void)strlcat(temp, TMPFILE, sizeof(temp));
578                 if ((fd = mkstemp(temp)) < 0) {
579                         warn("Unable to create temporary file `%s'", temp);
580                         return (NULL);
581                 }
582                 close(fd);
583                 oldverbose = verbose;
584                 verbose = (errbuf != NULL) ? -1 : 0;
585                 oldhash = hash;
586                 oldprogress = progress;
587                 hash = 0;
588                 progress = 0;
589                 if (doswitch)
590                         pswitch(!proxy);
591                 for (mode = "w"; *++argv != NULL; mode = "a")
592                         recvrequest("NLST", temp, *argv, mode, 0, 0);
593                 if ((code / 100) != COMPLETE) {
594                         if (errbuf != NULL)
595                                 *errbuf = reply_string;
596                 }
597                 if (doswitch)
598                         pswitch(!proxy);
599                 verbose = oldverbose;
600                 hash = oldhash;
601                 progress = oldprogress;
602                 ftemp = fopen(temp, "r");
603                 (void)unlink(temp);
604                 if (ftemp == NULL) {
605                         if (errbuf == NULL)
606                                 warnx("Can't find list of remote files");
607                         else
608                                 *errbuf =
609                                     "Can't find list of remote files";
610                         return (NULL);
611                 }
612         }
613         if (fgets(buf, sizeof(buf), ftemp) == NULL) {
614                 (void)fclose(ftemp);
615                 ftemp = NULL;
616                 return (NULL);
617         }
618         if ((cp = strchr(buf, '\n')) != NULL)
619                 *cp = '\0';
620         return (buf);
621 }
622
623 /*
624  * Glob a local file name specification with the expectation of a single
625  * return value. Can't control multiple values being expanded from the
626  * expression, we return only the first.
627  * Returns NULL on error, or a pointer to a buffer containing the filename
628  * that's the caller's responsiblity to free(3) when finished with.
629  */
630 char *
631 globulize(const char *pattern)
632 {
633         glob_t gl;
634         int flags;
635         char *p;
636
637         if (!doglob)
638                 return (ftp_strdup(pattern));
639
640         flags = GLOB_BRACE|GLOB_NOCHECK|GLOB_TILDE;
641         memset(&gl, 0, sizeof(gl));
642         if (glob(pattern, flags, NULL, &gl) || gl.gl_pathc == 0) {
643                 warnx("Glob pattern `%s' not found", pattern);
644                 globfree(&gl);
645                 return (NULL);
646         }
647         p = ftp_strdup(gl.gl_pathv[0]);
648         globfree(&gl);
649         return (p);
650 }
651
652 /*
653  * determine size of remote file
654  */
655 off_t
656 remotesize(const char *file, int noisy)
657 {
658         int overbose, r;
659         off_t size;
660
661         overbose = verbose;
662         size = -1;
663         if (ftp_debug == 0)
664                 verbose = -1;
665         if (! features[FEAT_SIZE]) {
666                 if (noisy)
667                         fprintf(ttyout,
668                             "SIZE is not supported by remote server.\n");
669                 goto cleanup_remotesize;
670         }
671         r = command("SIZE %s", file);
672         if (r == COMPLETE) {
673                 char *cp, *ep;
674
675                 cp = strchr(reply_string, ' ');
676                 if (cp != NULL) {
677                         cp++;
678                         size = STRTOLL(cp, &ep, 10);
679                         if (*ep != '\0' && !isspace((unsigned char)*ep))
680                                 size = -1;
681                 }
682         } else {
683                 if (r == ERROR && code == 500 && features[FEAT_SIZE] == -1)
684                         features[FEAT_SIZE] = 0;
685                 if (noisy && ftp_debug == 0) {
686                         fputs(reply_string, ttyout);
687                         putc('\n', ttyout);
688                 }
689         }
690  cleanup_remotesize:
691         verbose = overbose;
692         return (size);
693 }
694
695 /*
696  * determine last modification time (in GMT) of remote file
697  */
698 time_t
699 remotemodtime(const char *file, int noisy)
700 {
701         int     overbose, ocode, r;
702         time_t  rtime;
703
704         overbose = verbose;
705         ocode = code;
706         rtime = -1;
707         if (ftp_debug == 0)
708                 verbose = -1;
709         if (! features[FEAT_MDTM]) {
710                 if (noisy)
711                         fprintf(ttyout,
712                             "MDTM is not supported by remote server.\n");
713                 goto cleanup_parse_time;
714         }
715         r = command("MDTM %s", file);
716         if (r == COMPLETE) {
717                 struct tm timebuf;
718                 char *timestr, *frac;
719
720                 /*
721                  * time-val = 14DIGIT [ "." 1*DIGIT ]
722                  *              YYYYMMDDHHMMSS[.sss]
723                  * mdtm-response = "213" SP time-val CRLF / error-response
724                  */
725                 timestr = reply_string + 4;
726
727                                         /*
728                                          * parse fraction.
729                                          * XXX: ignored for now
730                                          */
731                 frac = strchr(timestr, '\r');
732                 if (frac != NULL)
733                         *frac = '\0';
734                 frac = strchr(timestr, '.');
735                 if (frac != NULL)
736                         *frac++ = '\0';
737                 if (strlen(timestr) == 15 && strncmp(timestr, "191", 3) == 0) {
738                         /*
739                          * XXX: Workaround for lame ftpd's that return
740                          *      `19100' instead of `2000'
741                          */
742                         fprintf(ttyout,
743             "Y2K warning! Incorrect time-val `%s' received from server.\n",
744                             timestr);
745                         timestr++;
746                         timestr[0] = '2';
747                         timestr[1] = '0';
748                         fprintf(ttyout, "Converted to `%s'\n", timestr);
749                 }
750                 memset(&timebuf, 0, sizeof(timebuf));
751                 if (strlen(timestr) != 14 ||
752                     (strptime(timestr, "%Y%m%d%H%M%S", &timebuf) == NULL)) {
753  bad_parse_time:
754                         fprintf(ttyout, "Can't parse time `%s'.\n", timestr);
755                         goto cleanup_parse_time;
756                 }
757                 timebuf.tm_isdst = -1;
758                 rtime = timegm(&timebuf);
759                 if (rtime == -1) {
760                         if (noisy || ftp_debug != 0)
761                                 goto bad_parse_time;
762                         else
763                                 goto cleanup_parse_time;
764                 } else
765                         DPRINTF("remotemodtime: parsed date `%s' as " LLF
766                             ", %s",
767                             timestr, (LLT)rtime,
768                             rfc2822time(localtime(&rtime)));
769         } else {
770                 if (r == ERROR && code == 500 && features[FEAT_MDTM] == -1)
771                         features[FEAT_MDTM] = 0;
772                 if (noisy && ftp_debug == 0) {
773                         fputs(reply_string, ttyout);
774                         putc('\n', ttyout);
775                 }
776         }
777  cleanup_parse_time:
778         verbose = overbose;
779         if (rtime == -1)
780                 code = ocode;
781         return (rtime);
782 }
783
784 /*
785  * Format tm in an RFC2822 compatible manner, with a trailing \n.
786  * Returns a pointer to a static string containing the result.
787  */
788 const char *
789 rfc2822time(const struct tm *tm)
790 {
791         static char result[50];
792
793         if (strftime(result, sizeof(result),
794             "%a, %d %b %Y %H:%M:%S %z\n", tm) == 0)
795                 errx(1, "Can't convert RFC2822 time: buffer too small");
796         return result;
797 }
798
799 /*
800  * Update global `localcwd', which contains the state of the local cwd
801  */
802 void
803 updatelocalcwd(void)
804 {
805
806         if (getcwd(localcwd, sizeof(localcwd)) == NULL)
807                 localcwd[0] = '\0';
808         DPRINTF("updatelocalcwd: got `%s'\n", localcwd);
809 }
810
811 /*
812  * Update global `remotecwd', which contains the state of the remote cwd
813  */
814 void
815 updateremotecwd(void)
816 {
817         int      overbose, ocode, i;
818         char    *cp;
819
820         overbose = verbose;
821         ocode = code;
822         if (ftp_debug == 0)
823                 verbose = -1;
824         if (command("PWD") != COMPLETE)
825                 goto badremotecwd;
826         cp = strchr(reply_string, ' ');
827         if (cp == NULL || cp[0] == '\0' || cp[1] != '"')
828                 goto badremotecwd;
829         cp += 2;
830         for (i = 0; *cp && i < sizeof(remotecwd) - 1; i++, cp++) {
831                 if (cp[0] == '"') {
832                         if (cp[1] == '"')
833                                 cp++;
834                         else
835                                 break;
836                 }
837                 remotecwd[i] = *cp;
838         }
839         remotecwd[i] = '\0';
840         DPRINTF("updateremotecwd: got `%s'\n", remotecwd);
841         goto cleanupremotecwd;
842  badremotecwd:
843         remotecwd[0]='\0';
844  cleanupremotecwd:
845         verbose = overbose;
846         code = ocode;
847 }
848
849 /*
850  * Ensure file is in or under dir.
851  * Returns 1 if so, 0 if not (or an error occurred).
852  */
853 int
854 fileindir(const char *file, const char *dir)
855 {
856         char    parentdirbuf[PATH_MAX+1], *parentdir;
857         char    realdir[PATH_MAX+1];
858         size_t  dirlen;
859
860                                         /* determine parent directory of file */
861         (void)strlcpy(parentdirbuf, file, sizeof(parentdirbuf));
862         parentdir = dirname(parentdirbuf);
863         if (strcmp(parentdir, ".") == 0)
864                 return 1;               /* current directory is ok */
865
866                                         /* find the directory */
867         if (realpath(parentdir, realdir) == NULL) {
868                 warn("Unable to determine real path of `%s'", parentdir);
869                 return 0;
870         }
871         if (realdir[0] != '/')          /* relative result is ok */
872                 return 1;
873         dirlen = strlen(dir);
874 #if 0
875 printf("file %s parent %s realdir %s dir %s [%d]\n",
876     file, parentdir, realdir, dir, dirlen);
877 #endif
878         if (strncmp(realdir, dir, dirlen) == 0 &&
879             (realdir[dirlen] == '/' || realdir[dirlen] == '\0'))
880                 return 1;
881         return 0;
882 }
883
884 /*
885  * List words in stringlist, vertically arranged
886  */
887 void
888 list_vertical(StringList *sl)
889 {
890         int i, j;
891         int columns, lines;
892         char *p;
893         size_t w, width;
894
895         width = 0;
896
897         for (i = 0 ; i < sl->sl_cur ; i++) {
898                 w = strlen(sl->sl_str[i]);
899                 if (w > width)
900                         width = w;
901         }
902         width = (width + 8) &~ 7;
903
904         columns = ttywidth / width;
905         if (columns == 0)
906                 columns = 1;
907         lines = (sl->sl_cur + columns - 1) / columns;
908         for (i = 0; i < lines; i++) {
909                 for (j = 0; j < columns; j++) {
910                         p = sl->sl_str[j * lines + i];
911                         if (p)
912                                 fputs(p, ttyout);
913                         if (j * lines + i + lines >= sl->sl_cur) {
914                                 putc('\n', ttyout);
915                                 break;
916                         }
917                         if (p) {
918                                 w = strlen(p);
919                                 while (w < width) {
920                                         w = (w + 8) &~ 7;
921                                         (void)putc('\t', ttyout);
922                                 }
923                         }
924                 }
925         }
926 }
927
928 /*
929  * Update the global ttywidth value, using TIOCGWINSZ.
930  */
931 void
932 setttywidth(int a)
933 {
934         struct winsize winsize;
935         int oerrno = errno;
936
937         if (ioctl(fileno(ttyout), TIOCGWINSZ, &winsize) != -1 &&
938             winsize.ws_col != 0)
939                 ttywidth = winsize.ws_col;
940         else
941                 ttywidth = 80;
942         errno = oerrno;
943 }
944
945 /*
946  * Change the rate limit up (SIGUSR1) or down (SIGUSR2)
947  */
948 void
949 crankrate(int sig)
950 {
951
952         switch (sig) {
953         case SIGUSR1:
954                 if (rate_get)
955                         rate_get += rate_get_incr;
956                 if (rate_put)
957                         rate_put += rate_put_incr;
958                 break;
959         case SIGUSR2:
960                 if (rate_get && rate_get > rate_get_incr)
961                         rate_get -= rate_get_incr;
962                 if (rate_put && rate_put > rate_put_incr)
963                         rate_put -= rate_put_incr;
964                 break;
965         default:
966                 err(1, "crankrate invoked with unknown signal: %d", sig);
967         }
968 }
969
970
971 /*
972  * Setup or cleanup EditLine structures
973  */
974 #ifndef NO_EDITCOMPLETE
975 void
976 controlediting(void)
977 {
978         if (editing && el == NULL && hist == NULL) {
979                 HistEvent ev;
980                 int editmode;
981
982                 el = el_init(getprogname(), stdin, ttyout, stderr);
983                 /* init editline */
984                 hist = history_init();          /* init the builtin history */
985                 history(hist, &ev, H_SETSIZE, 100);/* remember 100 events */
986                 el_set(el, EL_HIST, history, hist);     /* use history */
987
988                 el_set(el, EL_EDITOR, "emacs"); /* default editor is emacs */
989                 el_set(el, EL_PROMPT, prompt);  /* set the prompt functions */
990                 el_set(el, EL_RPROMPT, rprompt);
991
992                 /* add local file completion, bind to TAB */
993                 el_set(el, EL_ADDFN, "ftp-complete",
994                     "Context sensitive argument completion",
995                     complete);
996                 el_set(el, EL_BIND, "^I", "ftp-complete", NULL);
997                 el_source(el, NULL);    /* read ~/.editrc */
998                 if ((el_get(el, EL_EDITMODE, &editmode) != -1) && editmode == 0)
999                         editing = 0;    /* the user doesn't want editing,
1000                                          * so disable, and let statement
1001                                          * below cleanup */
1002                 else
1003                         el_set(el, EL_SIGNAL, 1);
1004         }
1005         if (!editing) {
1006                 if (hist) {
1007                         history_end(hist);
1008                         hist = NULL;
1009                 }
1010                 if (el) {
1011                         el_end(el);
1012                         el = NULL;
1013                 }
1014         }
1015 }
1016 #endif /* !NO_EDITCOMPLETE */
1017
1018 /*
1019  * Convert the string `arg' to an int, which may have an optional SI suffix
1020  * (`b', `k', `m', `g'). Returns the number for success, -1 otherwise.
1021  */
1022 int
1023 strsuftoi(const char *arg)
1024 {
1025         char *cp;
1026         long val;
1027
1028         if (!isdigit((unsigned char)arg[0]))
1029                 return (-1);
1030
1031         val = strtol(arg, &cp, 10);
1032         if (cp != NULL) {
1033                 if (cp[0] != '\0' && cp[1] != '\0')
1034                          return (-1);
1035                 switch (tolower((unsigned char)cp[0])) {
1036                 case '\0':
1037                 case 'b':
1038                         break;
1039                 case 'k':
1040                         val <<= 10;
1041                         break;
1042                 case 'm':
1043                         val <<= 20;
1044                         break;
1045                 case 'g':
1046                         val <<= 30;
1047                         break;
1048                 default:
1049                         return (-1);
1050                 }
1051         }
1052         if (val < 0 || val > INT_MAX)
1053                 return (-1);
1054
1055         return (val);
1056 }
1057
1058 /*
1059  * Set up socket buffer sizes before a connection is made.
1060  */
1061 void
1062 setupsockbufsize(int sock)
1063 {
1064
1065         if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF,
1066             (void *)&sndbuf_size, sizeof(sndbuf_size)) == -1)
1067                 warn("Unable to set sndbuf size %d", sndbuf_size);
1068
1069         if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
1070             (void *)&rcvbuf_size, sizeof(rcvbuf_size)) == -1)
1071                 warn("Unable to set rcvbuf size %d", rcvbuf_size);
1072 }
1073
1074 /*
1075  * Copy characters from src into dst, \ quoting characters that require it
1076  */
1077 void
1078 ftpvis(char *dst, size_t dstlen, const char *src, size_t srclen)
1079 {
1080         int     di, si;
1081
1082         for (di = si = 0;
1083             src[si] != '\0' && di < dstlen && si < srclen;
1084             di++, si++) {
1085                 switch (src[si]) {
1086                 case '\\':
1087                 case ' ':
1088                 case '\t':
1089                 case '\r':
1090                 case '\n':
1091                 case '"':
1092                         dst[di++] = '\\';
1093                         if (di >= dstlen)
1094                                 break;
1095                         /* FALLTHROUGH */
1096                 default:
1097                         dst[di] = src[si];
1098                 }
1099         }
1100         dst[di] = '\0';
1101 }
1102
1103 /*
1104  * Copy src into buf (which is len bytes long), expanding % sequences.
1105  */
1106 void
1107 formatbuf(char *buf, size_t len, const char *src)
1108 {
1109         const char      *p, *p2, *q;
1110         int              i, op, updirs, pdirs;
1111
1112 #define ADDBUF(x) do { \
1113                 if (i >= len - 1) \
1114                         goto endbuf; \
1115                 buf[i++] = (x); \
1116         } while (0)
1117
1118         p = src;
1119         for (i = 0; *p; p++) {
1120                 if (*p != '%') {
1121                         ADDBUF(*p);
1122                         continue;
1123                 }
1124                 p++;
1125
1126                 switch (op = *p) {
1127
1128                 case '/':
1129                 case '.':
1130                 case 'c':
1131                         p2 = connected ? remotecwd : "";
1132                         updirs = pdirs = 0;
1133
1134                         /* option to determine fixed # of dirs from path */
1135                         if (op == '.' || op == 'c') {
1136                                 int skip;
1137
1138                                 q = p2;
1139                                 while (*p2)             /* calc # of /'s */
1140                                         if (*p2++ == '/')
1141                                                 updirs++;
1142                                 if (p[1] == '0') {      /* print <x> or ... */
1143                                         pdirs = 1;
1144                                         p++;
1145                                 }
1146                                 if (p[1] >= '1' && p[1] <= '9') {
1147                                                         /* calc # to skip  */
1148                                         skip = p[1] - '0';
1149                                         p++;
1150                                 } else
1151                                         skip = 1;
1152
1153                                 updirs -= skip;
1154                                 while (skip-- > 0) {
1155                                         while ((p2 > q) && (*p2 != '/'))
1156                                                 p2--;   /* back up */
1157                                         if (skip && p2 > q)
1158                                                 p2--;
1159                                 }
1160                                 if (*p2 == '/' && p2 != q)
1161                                         p2++;
1162                         }
1163
1164                         if (updirs > 0 && pdirs) {
1165                                 if (i >= len - 5)
1166                                         break;
1167                                 if (op == '.') {
1168                                         ADDBUF('.');
1169                                         ADDBUF('.');
1170                                         ADDBUF('.');
1171                                 } else {
1172                                         ADDBUF('/');
1173                                         ADDBUF('<');
1174                                         if (updirs > 9) {
1175                                                 ADDBUF('9');
1176                                                 ADDBUF('+');
1177                                         } else
1178                                                 ADDBUF('0' + updirs);
1179                                         ADDBUF('>');
1180                                 }
1181                         }
1182                         for (; *p2; p2++)
1183                                 ADDBUF(*p2);
1184                         break;
1185
1186                 case 'M':
1187                 case 'm':
1188                         for (p2 = connected && hostname ? hostname : "-";
1189                             *p2 ; p2++) {
1190                                 if (op == 'm' && *p2 == '.')
1191                                         break;
1192                                 ADDBUF(*p2);
1193                         }
1194                         break;
1195
1196                 case 'n':
1197                         for (p2 = connected ? username : "-"; *p2 ; p2++)
1198                                 ADDBUF(*p2);
1199                         break;
1200
1201                 case '%':
1202                         ADDBUF('%');
1203                         break;
1204
1205                 default:                /* display unknown codes literally */
1206                         ADDBUF('%');
1207                         ADDBUF(op);
1208                         break;
1209
1210                 }
1211         }
1212  endbuf:
1213         buf[i] = '\0';
1214 }
1215
1216 /*
1217  * Parse `port' into a TCP port number, defaulting to `defport' if `port' is
1218  * an unknown service name. If defport != -1, print a warning upon bad parse.
1219  */
1220 int
1221 parseport(const char *port, int defport)
1222 {
1223         int      rv;
1224         long     nport;
1225         char    *p, *ep;
1226
1227         p = ftp_strdup(port);
1228         nport = strtol(p, &ep, 10);
1229         if (*ep != '\0' && ep == p) {
1230                 struct servent  *svp;
1231
1232                 svp = getservbyname(port, "tcp");
1233                 if (svp == NULL) {
1234  badparseport:
1235                         if (defport != -1)
1236                                 warnx("Unknown port `%s', using port %d",
1237                                     port, defport);
1238                         rv = defport;
1239                 } else
1240                         rv = ntohs(svp->s_port);
1241         } else if (nport < 1 || nport > MAX_IN_PORT_T || *ep != '\0')
1242                 goto badparseport;
1243         else
1244                 rv = nport;
1245         free(p);
1246         return (rv);
1247 }
1248
1249 /*
1250  * Determine if given string is an IPv6 address or not.
1251  * Return 1 for yes, 0 for no
1252  */
1253 int
1254 isipv6addr(const char *addr)
1255 {
1256         int rv = 0;
1257 #ifdef INET6
1258         struct addrinfo hints, *res;
1259
1260         memset(&hints, 0, sizeof(hints));
1261         hints.ai_family = PF_INET6;
1262         hints.ai_socktype = SOCK_DGRAM; /*dummy*/
1263         hints.ai_flags = AI_NUMERICHOST;
1264         if (getaddrinfo(addr, "0", &hints, &res) != 0)
1265                 rv = 0;
1266         else {
1267                 rv = 1;
1268                 freeaddrinfo(res);
1269         }
1270         DPRINTF("isipv6addr: got %d for %s\n", rv, addr);
1271 #endif
1272         return (rv == 1) ? 1 : 0;
1273 }
1274
1275 /*
1276  * Read a line from the FILE stream into buf/buflen using fgets(), so up
1277  * to buflen-1 chars will be read and the result will be NUL terminated.
1278  * If the line has a trailing newline it will be removed.
1279  * If the line is too long, excess characters will be read until
1280  * newline/EOF/error.
1281  * If EOF/error occurs or a too-long line is encountered and errormsg
1282  * isn't NULL, it will be changed to a description of the problem.
1283  * (The EOF message has a leading \n for cosmetic purposes).
1284  * Returns:
1285  *      >=0     length of line (excluding trailing newline) if all ok
1286  *      -1      error occurred
1287  *      -2      EOF encountered
1288  *      -3      line was too long
1289  */
1290 int
1291 getline(FILE *stream, char *buf, size_t buflen, const char **errormsg)
1292 {
1293         int     rv, ch;
1294         size_t  len;
1295
1296         if (fgets(buf, buflen, stream) == NULL) {
1297                 if (feof(stream)) {     /* EOF */
1298                         rv = -2;
1299                         if (errormsg)
1300                                 *errormsg = "\nEOF received";
1301                 } else  {               /* error */
1302                         rv = -1;
1303                         if (errormsg)
1304                                 *errormsg = "Error encountered";
1305                 }
1306                 clearerr(stream);
1307                 return rv;
1308         }
1309         len = strlen(buf);
1310         if (buf[len-1] == '\n') {       /* clear any trailing newline */
1311                 buf[--len] = '\0';
1312         } else if (len == buflen-1) {   /* line too long */
1313                 while ((ch = getchar()) != '\n' && ch != EOF)
1314                         continue;
1315                 if (errormsg)
1316                         *errormsg = "Input line is too long";
1317                 clearerr(stream);
1318                 return -3;
1319         }
1320         if (errormsg)
1321                 *errormsg = NULL;
1322         return len;
1323 }
1324
1325 /*
1326  * Internal version of connect(2); sets socket buffer sizes,
1327  * binds to a specific local address (if set), and
1328  * supports a connection timeout using a non-blocking connect(2) with
1329  * a poll(2).
1330  * Socket fcntl flags are temporarily updated to include O_NONBLOCK;
1331  * these will not be reverted on connection failure.
1332  * Returns 0 on success, or -1 upon failure (with an appropriate
1333  * error message displayed.)
1334  */
1335 int
1336 ftp_connect(int sock, const struct sockaddr *name, socklen_t namelen)
1337 {
1338         int             flags, rv, timeout, error;
1339         socklen_t       slen;
1340         struct timeval  endtime, now, td;
1341         struct pollfd   pfd[1];
1342         char            hname[NI_MAXHOST];
1343
1344         setupsockbufsize(sock);
1345         if (getnameinfo(name, namelen,
1346             hname, sizeof(hname), NULL, 0, NI_NUMERICHOST) != 0)
1347                 strlcpy(hname, "?", sizeof(hname));
1348
1349         if (bindai != NULL) {                   /* bind to specific addr */
1350                 struct addrinfo *ai;
1351
1352                 for (ai = bindai; ai != NULL; ai = ai->ai_next) {
1353                         if (ai->ai_family == name->sa_family)
1354                                 break;
1355                 }
1356                 if (ai == NULL)
1357                         ai = bindai;
1358                 if (bind(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
1359                         char    bname[NI_MAXHOST];
1360                         int     saveerr;
1361
1362                         saveerr = errno;
1363                         if (getnameinfo(ai->ai_addr, ai->ai_addrlen,
1364                             bname, sizeof(bname), NULL, 0, NI_NUMERICHOST) != 0)
1365                                 strlcpy(bname, "?", sizeof(bname));
1366                         errno = saveerr;
1367                         warn("Can't bind to `%s'", bname);
1368                         return -1;
1369                 }
1370         }
1371
1372                                                 /* save current socket flags */
1373         if ((flags = fcntl(sock, F_GETFL, 0)) == -1) {
1374                 warn("Can't %s socket flags for connect to `%s'",
1375                     "save", hname);
1376                 return -1;
1377         }
1378                                                 /* set non-blocking connect */
1379         if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
1380                 warn("Can't set socket non-blocking for connect to `%s'",
1381                     hname);
1382                 return -1;
1383         }
1384
1385         /* NOTE: we now must restore socket flags on successful exit */
1386
1387         pfd[0].fd = sock;
1388         pfd[0].events = POLLIN|POLLOUT;
1389
1390         if (quit_time > 0) {                    /* want a non default timeout */
1391                 (void)gettimeofday(&endtime, NULL);
1392                 endtime.tv_sec += quit_time;    /* determine end time */
1393         }
1394
1395         rv = connect(sock, name, namelen);      /* inititate the connection */
1396         if (rv == -1) {                         /* connection error */
1397                 if (errno != EINPROGRESS) {     /* error isn't "please wait" */
1398  connecterror:
1399                         warn("Can't connect to `%s'", hname);
1400                         return -1;
1401                 }
1402
1403                                                 /* connect EINPROGRESS; wait */
1404                 do {
1405                         if (quit_time > 0) {    /* determine timeout */
1406                                 (void)gettimeofday(&now, NULL);
1407                                 timersub(&endtime, &now, &td);
1408                                 timeout = td.tv_sec * 1000 + td.tv_usec/1000;
1409                                 if (timeout < 0)
1410                                         timeout = 0;
1411                         } else {
1412                                 timeout = INFTIM;
1413                         }
1414                         pfd[0].revents = 0;
1415                         rv = ftp_poll(pfd, 1, timeout);
1416                                                 /* loop until poll ! EINTR */
1417                 } while (rv == -1 && errno == EINTR);
1418
1419                 if (rv == 0) {                  /* poll (connect) timed out */
1420                         errno = ETIMEDOUT;
1421                         goto connecterror;
1422                 }
1423
1424                 if (rv == -1) {                 /* poll error */
1425                         goto connecterror;
1426                 } else if (pfd[0].revents & (POLLIN|POLLOUT)) {
1427                         slen = sizeof(error);   /* OK, or pending error */
1428                         if (getsockopt(sock, SOL_SOCKET, SO_ERROR,
1429                             &error, &slen) == -1) {
1430                                                 /* Solaris pending error */
1431                                 goto connecterror;
1432                         } else if (error != 0) {
1433                                 errno = error;  /* BSD pending error */
1434                                 goto connecterror;
1435                         }
1436                 } else {
1437                         errno = EBADF;          /* this shouldn't happen ... */
1438                         goto connecterror;
1439                 }
1440         }
1441
1442         if (fcntl(sock, F_SETFL, flags) == -1) {
1443                                                 /* restore socket flags */
1444                 warn("Can't %s socket flags for connect to `%s'",
1445                     "restore", hname);
1446                 return -1;
1447         }
1448         return 0;
1449 }
1450
1451 /*
1452  * Internal version of listen(2); sets socket buffer sizes first.
1453  */
1454 int
1455 ftp_listen(int sock, int backlog)
1456 {
1457
1458         setupsockbufsize(sock);
1459         return (listen(sock, backlog));
1460 }
1461
1462 /*
1463  * Internal version of poll(2), to allow reimplementation by select(2)
1464  * on platforms without the former.
1465  */
1466 int
1467 ftp_poll(struct pollfd *fds, int nfds, int timeout)
1468 {
1469         return poll(fds, nfds, timeout);
1470 }
1471
1472 /*
1473  * malloc() with inbuilt error checking
1474  */
1475 void *
1476 ftp_malloc(size_t size)
1477 {
1478         void *p;
1479
1480         p = malloc(size);
1481         if (p == NULL)
1482                 err(1, "Unable to allocate %ld bytes of memory", (long)size);
1483         return (p);
1484 }
1485
1486 /*
1487  * sl_init() with inbuilt error checking
1488  */
1489 StringList *
1490 ftp_sl_init(void)
1491 {
1492         StringList *p;
1493
1494         p = sl_init();
1495         if (p == NULL)
1496                 err(1, "Unable to allocate memory for stringlist");
1497         return (p);
1498 }
1499
1500 /*
1501  * sl_add() with inbuilt error checking
1502  */
1503 void
1504 ftp_sl_add(StringList *sl, char *i)
1505 {
1506
1507         if (sl_add(sl, i) == -1)
1508                 err(1, "Unable to add `%s' to stringlist", i);
1509 }
1510
1511 /*
1512  * strdup() with inbuilt error checking
1513  */
1514 char *
1515 ftp_strdup(const char *str)
1516 {
1517         char *s;
1518
1519         if (str == NULL)
1520                 errx(1, "ftp_strdup: called with NULL argument");
1521         s = strdup(str);
1522         if (s == NULL)
1523                 err(1, "Unable to allocate memory for string copy");
1524         return (s);
1525 }