Annotation of embedaddon/mini_sendmail/mini_sendmail.c, revision 1.1
1.1 ! misho 1: /* mini_sendmail - accept email on behalf of real sendmail
! 2: **
! 3: ** Copyright © 1999 by Jef Poskanzer <jef@mail.acme.com>.
! 4: ** All rights reserved.
! 5: **
! 6: ** Redistribution and use in source and binary forms, with or without
! 7: ** modification, are permitted provided that the following conditions
! 8: ** are met:
! 9: ** 1. Redistributions of source code must retain the above copyright
! 10: ** notice, this list of conditions and the following disclaimer.
! 11: ** 2. Redistributions in binary form must reproduce the above copyright
! 12: ** notice, this list of conditions and the following disclaimer in the
! 13: ** documentation and/or other materials provided with the distribution.
! 14: **
! 15: ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 16: ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 17: ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 18: ** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 19: ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 20: ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 21: ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 22: ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 23: ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 24: ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 25: ** SUCH DAMAGE.
! 26: */
! 27:
! 28:
! 29: /* These defines control some optional features of the program. If you
! 30: ** don't want the features you can undef the symbols; some of them mean
! 31: ** a significant savings in executable size.
! 32: */
! 33: #define DO_RECEIVED /* whether to add a "Received:" header */
! 34: #define DO_GETPWUID /* whether to try a getpwuid() if getlogin() fails */
! 35: #define DO_MINUS_SP /* whether to implement the -s and -p flags */
! 36: #define DO_DNS /* whether to do a name lookup on -s, or just IP# */
! 37:
! 38:
! 39: #include <unistd.h>
! 40: #include <stdlib.h>
! 41: #include <stdio.h>
! 42: #include <signal.h>
! 43: #include <string.h>
! 44: #include <sys/types.h>
! 45: #include <sys/socket.h>
! 46: #include <netinet/in.h>
! 47: #include <netdb.h>
! 48:
! 49: #ifdef DO_RECEIVED
! 50: #include <time.h>
! 51: #endif /* DO_RECEIVED */
! 52: #ifdef DO_GETPWUID
! 53: #include <pwd.h>
! 54: #endif /* DO_GETPWUID */
! 55:
! 56: #include "version.h"
! 57:
! 58:
! 59: /* Defines. */
! 60: #define SMTP_PORT 25
! 61: #define DEFAULT_TIMEOUT 60
! 62:
! 63:
! 64: /* Globals. */
! 65: static char* argv0;
! 66: static char* fake_from;
! 67: static int parse_message, verbose;
! 68: #ifdef DO_MINUS_SP
! 69: static char* server;
! 70: static short port;
! 71: #endif /* DO_MINUS_SP */
! 72: static int timeout;
! 73: static int sockfd1, sockfd2;
! 74: static FILE* sockrfp;
! 75: static FILE* sockwfp;
! 76: static int got_a_recipient;
! 77:
! 78:
! 79: /* Forwards. */
! 80: static void usage( void );
! 81: static char* slurp_message( void );
! 82: #ifdef DO_RECEIVED
! 83: static char* make_received( char* from, char* username, char* hostname );
! 84: #endif /* DO_RECEIVED */
! 85: static void parse_for_recipients( char* message );
! 86: static void add_recipient( char* recipient, int len );
! 87: static int open_client_socket( void );
! 88: static int read_response( void );
! 89: static void send_command( char* command );
! 90: static void send_data( char* data );
! 91: static void send_done( void );
! 92: static void sigcatch( int sig );
! 93: static void show_error( char* cause );
! 94:
! 95:
! 96: int
! 97: main( int argc, char** argv )
! 98: {
! 99: int argn;
! 100: char* message;
! 101: #ifdef DO_RECEIVED
! 102: char* received;
! 103: #endif /* DO_RECEIVED */
! 104: char* username;
! 105: char hostname[500];
! 106: char from[1000];
! 107: int status;
! 108: char buf[2000];
! 109:
! 110: /* Parse args. */
! 111: argv0 = argv[0];
! 112: fake_from = (char*) 0;
! 113: parse_message = 0;
! 114: #ifdef DO_MINUS_SP
! 115: server = "127.0.0.1";
! 116: port = SMTP_PORT;
! 117: #endif /* DO_MINUS_SP */
! 118: verbose = 0;
! 119: timeout = DEFAULT_TIMEOUT;
! 120: argn = 1;
! 121: while ( argn < argc && argv[argn][0] == '-' )
! 122: {
! 123: if ( strncmp( argv[argn], "-f", 2 ) == 0 && argv[argn][2] != '\0' )
! 124: fake_from = &(argv[argn][2]);
! 125: else if ( strcmp( argv[argn], "-t" ) == 0 )
! 126: parse_message = 1;
! 127: #ifdef DO_MINUS_SP
! 128: else if ( strncmp( argv[argn], "-s", 2 ) == 0 && argv[argn][2] != '\0' )
! 129: server = &(argv[argn][2]);
! 130: else if ( strncmp( argv[argn], "-p", 2 ) == 0 && argv[argn][2] != '\0' )
! 131: port = atoi( &(argv[argn][2]) );
! 132: #endif /* DO_MINUS_SP */
! 133: else if ( strncmp( argv[argn], "-T", 2 ) == 0 && argv[argn][2] != '\0' )
! 134: timeout = atoi( &(argv[argn][2]) );
! 135: else if ( strcmp( argv[argn], "-v" ) == 0 )
! 136: verbose = 1;
! 137: else if ( strcmp( argv[argn], "-i" ) == 0 )
! 138: ; /* ignore */
! 139: else if ( strcmp( argv[argn], "-oi" ) == 0 )
! 140: ; /* ignore */
! 141: else if ( strcmp( argv[argn], "--" ) == 0 )
! 142: ; /* ignore */
! 143: else
! 144: usage();
! 145: ++argn;
! 146: }
! 147:
! 148: username = getlogin();
! 149: if ( username == (char*) 0 )
! 150: {
! 151: #ifdef DO_GETPWUID
! 152: struct passwd* pw = getpwuid( getuid() );
! 153: if ( pw == (struct passwd*) 0 )
! 154: {
! 155: (void) fprintf( stderr, "%s: can't determine username\n", argv0 );
! 156: exit( 1 );
! 157: }
! 158: username = pw->pw_name;
! 159: #else /* DO_GETPWUID */
! 160: (void) fprintf( stderr, "%s: can't determine username\n", argv0 );
! 161: exit( 1 );
! 162: #endif /* DO_GETPWUID */
! 163: }
! 164:
! 165: if ( gethostname( hostname, sizeof(hostname) - 1 ) < 0 )
! 166: show_error( "gethostname" );
! 167:
! 168: if ( fake_from == (char*) 0 )
! 169: (void) snprintf( from, sizeof(from), "%s@%s", username, hostname );
! 170: else
! 171: if ( strchr( fake_from, '@' ) == (char*) 0 )
! 172: (void) snprintf( from, sizeof(from), "%s@%s", fake_from, hostname );
! 173: else
! 174: (void) snprintf( from, sizeof(from), "%s", fake_from );
! 175:
! 176: /* Strip off any angle brackets in the from address. */
! 177: while ( from[0] == '<' )
! 178: (void) strcpy( from, &from[1] );
! 179: while ( from[strlen(from)-1] == '>' )
! 180: from[strlen(from)-1] = '\0';
! 181:
! 182: message = slurp_message();
! 183: #ifdef DO_RECEIVED
! 184: received = make_received( from, username, hostname );
! 185: #endif /* DO_RECEIVED */
! 186:
! 187: (void) signal( SIGALRM, sigcatch );
! 188:
! 189: (void) alarm( timeout );
! 190: sockfd1 = open_client_socket();
! 191:
! 192: sockfd2 = dup( sockfd1 );
! 193: sockrfp = fdopen( sockfd1, "r" );
! 194: sockwfp = fdopen( sockfd2, "w" );
! 195:
! 196: /* The full SMTP protocol is spelled out in RFC821, available at
! 197: ** http://www.faqs.org/rfcs/rfc821.html
! 198: ** The only non-obvious wrinkles:
! 199: ** - The commands are terminated with CRLF, not newline.
! 200: ** - Newlines in the data file get turned into CRLFs.
! 201: ** - Any data lines beginning with a period get an extra period prepended.
! 202: */
! 203:
! 204: status = read_response();
! 205: if ( status != 220 )
! 206: {
! 207: (void) fprintf(
! 208: stderr, "%s: unexpected initial greeting %d\n", argv0, status );
! 209: exit( 1 );
! 210: }
! 211:
! 212: (void) snprintf( buf, sizeof(buf), "HELO %s", hostname );
! 213: send_command( buf );
! 214: status = read_response();
! 215: if ( status != 250 )
! 216: {
! 217: (void) fprintf(
! 218: stderr, "%s: unexpected response %d to HELO command\n",
! 219: argv0, status );
! 220: exit( 1 );
! 221: }
! 222:
! 223: (void) snprintf( buf, sizeof(buf), "MAIL FROM:<%s>", from );
! 224: send_command( buf );
! 225: status = read_response();
! 226: if ( status != 250 )
! 227: {
! 228: (void) fprintf(
! 229: stderr, "%s: unexpected response %d to MAIL FROM command\n",
! 230: argv0, status );
! 231: exit( 1 );
! 232: }
! 233:
! 234: got_a_recipient = 0;
! 235: for ( ; argn < argc; ++argn )
! 236: add_recipient( argv[argn], strlen( argv[argn] ) );
! 237: if ( parse_message )
! 238: parse_for_recipients( message );
! 239: if ( ! got_a_recipient )
! 240: {
! 241: (void) fprintf( stderr, "%s: no recipients found\n", argv0 );
! 242: exit( 1 );
! 243: }
! 244:
! 245: send_command( "DATA" );
! 246: status = read_response();
! 247: if ( status != 354 )
! 248: {
! 249: (void) fprintf(
! 250: stderr, "%s: unexpected response %d to DATA command\n",
! 251: argv0, status );
! 252: exit( 1 );
! 253: }
! 254:
! 255: #ifdef DO_RECEIVED
! 256: send_data( received );
! 257: #endif /* DO_RECEIVED */
! 258: send_data( message );
! 259: send_done();
! 260: status = read_response();
! 261: if ( status != 250 )
! 262: {
! 263: (void) fprintf(
! 264: stderr, "%s: unexpected response %d to DATA\n", argv0, status );
! 265: exit( 1 );
! 266: }
! 267:
! 268: send_command( "QUIT" );
! 269: status = read_response();
! 270: if ( status != 221 )
! 271: (void) fprintf(
! 272: stderr, "%s: unexpected response %d to QUIT command - ignored\n",
! 273: argv0, status );
! 274:
! 275: (void) close( sockfd1 );
! 276: (void) close( sockfd2 );
! 277:
! 278: exit( 0 );
! 279: }
! 280:
! 281:
! 282: static void
! 283: usage( void )
! 284: {
! 285: #ifdef DO_MINUS_SP
! 286: #ifdef DO_DNS
! 287: char* spflag = "[-s<server>] [-p<port>] ";
! 288: #else /* DO_DNS */
! 289: char* spflag = "[-s<server_ip>] [-p<port>] ";
! 290: #endif /* DO_DNS */
! 291: #else /* DO_MINUS_SP */
! 292: char* spflag = "";
! 293: #endif /* DO_MINUS_SP */
! 294: (void) fprintf( stderr, "usage: %s [-f<name>] [-t] %s[-T<timeout>] [-v] [address ...]\n", argv0, spflag );
! 295: exit( 1 );
! 296: }
! 297:
! 298:
! 299: static char*
! 300: slurp_message( void )
! 301: {
! 302: char* message;
! 303: int message_size, message_len;
! 304: int c;
! 305:
! 306: message_size = 5000;
! 307: message = (char*) malloc( message_size );
! 308: if ( message == (char*) 0 )
! 309: {
! 310: (void) fprintf( stderr, "%s: out of memory\n", argv0 );
! 311: exit( 1 );
! 312: }
! 313: message_len = 0;
! 314:
! 315: for (;;)
! 316: {
! 317: c = getchar();
! 318: if ( c == EOF )
! 319: break;
! 320: if ( message_len + 1 >= message_size )
! 321: {
! 322: message_size *= 2;
! 323: message = (char*) realloc( (void*) message, message_size );
! 324: if ( message == (char*) 0 )
! 325: {
! 326: (void) fprintf( stderr, "%s: out of memory\n", argv0 );
! 327: exit( 1 );
! 328: }
! 329: }
! 330: message[message_len++] = c;
! 331: }
! 332: message[message_len] = '\0';
! 333:
! 334: return message;
! 335: }
! 336:
! 337:
! 338: #ifdef DO_RECEIVED
! 339: static char*
! 340: make_received( char* from, char* username, char* hostname )
! 341: {
! 342: int received_size;
! 343: char* received;
! 344: time_t t;
! 345: struct tm* tmP;
! 346: char timestamp[100];
! 347:
! 348: t = time( (time_t*) 0 );
! 349: tmP = localtime( &t );
! 350: (void) strftime( timestamp, sizeof(timestamp), "%a, %d %b %Y %T %Z", tmP );
! 351: received_size =
! 352: 500 + strlen( from ) + strlen( hostname ) * 2 + strlen( VERSION ) +
! 353: strlen( timestamp ) + strlen( username );
! 354: received = (char*) malloc( received_size );
! 355: if ( received == (char*) 0 )
! 356: {
! 357: (void) fprintf( stderr, "%s: out of memory\n", argv0 );
! 358: exit( 1 );
! 359: }
! 360: (void) snprintf(
! 361: received, received_size,
! 362: "Received: (from %s)\n\tby %s (%s);\n\t%s\n\t(sender %s@%s)\n",
! 363: from, hostname, VERSION, timestamp, username, hostname );
! 364: return received;
! 365: }
! 366: #endif /* DO_RECEIVED */
! 367:
! 368:
! 369: static void
! 370: parse_for_recipients( char* message )
! 371: {
! 372: /* A little finite-state machine that parses the message, looking
! 373: ** for To:, Cc:, and Bcc: recipients.
! 374: */
! 375: int state;
! 376: #define ST_BOL 0
! 377: #define ST_OTHERHEAD 1
! 378: #define ST_T 2
! 379: #define ST_C 3
! 380: #define ST_B 4
! 381: #define ST_BC 5
! 382: #define ST_RECIPHEAD 6
! 383: #define ST_RECIPS 7
! 384: char* cp;
! 385: char* bcc;
! 386: char* recip;
! 387:
! 388: state = ST_BOL;
! 389: bcc = (char*) 0;
! 390: for ( cp = message; *cp != '\0'; ++cp )
! 391: {
! 392: switch ( state )
! 393: {
! 394: case ST_BOL:
! 395: switch ( *cp )
! 396: {
! 397: case '\n':
! 398: return;
! 399: case 'T':
! 400: case 't':
! 401: state = ST_T;
! 402: break;
! 403: case 'C':
! 404: case 'c':
! 405: state = ST_C;
! 406: break;
! 407: case 'B':
! 408: case 'b':
! 409: state = ST_B;
! 410: bcc = cp;
! 411: break;
! 412: default:
! 413: state = ST_OTHERHEAD;
! 414: break;
! 415: }
! 416: break;
! 417: case ST_OTHERHEAD:
! 418: switch ( *cp )
! 419: {
! 420: case '\n':
! 421: state = ST_BOL;
! 422: break;
! 423: }
! 424: break;
! 425: case ST_T:
! 426: switch ( *cp )
! 427: {
! 428: case '\n':
! 429: state = ST_BOL;
! 430: break;
! 431: case 'O':
! 432: case 'o':
! 433: state = ST_RECIPHEAD;
! 434: break;
! 435: default:
! 436: state = ST_OTHERHEAD;
! 437: break;
! 438: }
! 439: break;
! 440: case ST_C:
! 441: switch ( *cp )
! 442: {
! 443: case '\n':
! 444: state = ST_BOL;
! 445: break;
! 446: case 'C':
! 447: case 'c':
! 448: state = ST_RECIPHEAD;
! 449: break;
! 450: default:
! 451: state = ST_OTHERHEAD;
! 452: break;
! 453: }
! 454: break;
! 455: case ST_B:
! 456: switch ( *cp )
! 457: {
! 458: case '\n':
! 459: state = ST_BOL;
! 460: bcc = (char*) 0;
! 461: break;
! 462: case 'C':
! 463: case 'c':
! 464: state = ST_BC;
! 465: break;
! 466: default:
! 467: state = ST_OTHERHEAD;
! 468: bcc = (char*) 0;
! 469: break;
! 470: }
! 471: break;
! 472: case ST_BC:
! 473: switch ( *cp )
! 474: {
! 475: case '\n':
! 476: state = ST_BOL;
! 477: bcc = (char*) 0;
! 478: break;
! 479: case 'C':
! 480: case 'c':
! 481: state = ST_RECIPHEAD;
! 482: break;
! 483: default:
! 484: state = ST_OTHERHEAD;
! 485: bcc = (char*) 0;
! 486: break;
! 487: }
! 488: break;
! 489: case ST_RECIPHEAD:
! 490: switch ( *cp )
! 491: {
! 492: case '\n':
! 493: state = ST_BOL;
! 494: bcc = (char*) 0;
! 495: break;
! 496: case ':':
! 497: state = ST_RECIPS;
! 498: recip = cp + 1;
! 499: break;
! 500: default:
! 501: state = ST_OTHERHEAD;
! 502: bcc = (char*) 0;
! 503: break;
! 504: }
! 505: break;
! 506: case ST_RECIPS:
! 507: switch ( *cp )
! 508: {
! 509: case '\n':
! 510: add_recipient( recip, ( cp - recip ) );
! 511: state = ST_BOL;
! 512: if ( bcc != (char*) 0 )
! 513: {
! 514: /* Elide the Bcc: line, and reset cp. */
! 515: (void) strcpy( bcc, cp + 1 );
! 516: cp = bcc - 1;
! 517: bcc = (char*) 0;
! 518: }
! 519: break;
! 520: case ',':
! 521: add_recipient( recip, ( cp - recip ) );
! 522: recip = cp + 1;
! 523: break;
! 524: }
! 525: break;
! 526: }
! 527: }
! 528: }
! 529:
! 530:
! 531: static void
! 532: add_recipient( char* recipient, int len )
! 533: {
! 534: char buf[1000];
! 535: int status;
! 536:
! 537: /* Skip leading whitespace. */
! 538: while ( len > 0 && ( *recipient == ' ' || *recipient == '\t' ) )
! 539: {
! 540: ++recipient;
! 541: --len;
! 542: }
! 543:
! 544: /* Strip off any angle brackets. */
! 545: /*
! 546: while ( len > 0 && *recipient == '<' )
! 547: {
! 548: ++recipient;
! 549: --len;
! 550: }
! 551: while ( len > 0 && recipient[len-1] == '>' )
! 552: --len;
! 553:
! 554: (void) snprintf( buf, sizeof(buf), "RCPT TO:<%.*s>", len, recipient );
! 555: */
! 556: if (len > 0 && recipient[len-1] == '>' )
! 557: {
! 558: /* "<name@domain>" or: "Full Name <name@domain>" */
! 559: while (len > 0 && *recipient != '<' )
! 560: {
! 561: ++recipient;
! 562: --len;
! 563: }
! 564: (void) snprintf( buf, sizeof(buf), "RCPT TO:%.*s", len, recipient );
! 565: }
! 566: else
! 567: {
! 568: /* name@domain */
! 569: (void) snprintf( buf, sizeof(buf), "RCPT TO:<%.*s>", len, recipient );
! 570: }
! 571:
! 572: send_command( buf );
! 573: status = read_response();
! 574: if ( status != 250 && status != 251 )
! 575: {
! 576: (void) fprintf(
! 577: stderr, "%s: unexpected response %d to RCPT TO command\n",
! 578: argv0, status );
! 579: exit( 1 );
! 580: }
! 581: got_a_recipient = 1;
! 582: }
! 583:
! 584:
! 585: #if defined(AF_INET6) && defined(IN6_IS_ADDR_V4MAPPED)
! 586: #define USE_IPV6
! 587: #endif
! 588:
! 589: static int
! 590: open_client_socket( void )
! 591: {
! 592: #ifdef USE_IPV6
! 593: struct sockaddr_in6 sa;
! 594: #else /* USE_IPV6 */
! 595: struct sockaddr_in sa;
! 596: #endif /* USE_IPV6 */
! 597: int sa_len, sock_family, sock_type, sock_protocol;
! 598: int sockfd;
! 599:
! 600: sock_type = SOCK_STREAM;
! 601: sock_protocol = 0;
! 602: sa_len = sizeof(sa);
! 603: (void) memset( (void*) &sa, 0, sa_len );
! 604:
! 605: #ifdef USE_IPV6
! 606:
! 607: {
! 608: #ifdef DO_MINUS_SP
! 609: struct sockaddr_in sa4;
! 610: struct addrinfo hints;
! 611: char portstr[10];
! 612: int gaierr;
! 613: struct addrinfo* ai;
! 614: struct addrinfo* ai2;
! 615: struct addrinfo* aiv4;
! 616: struct addrinfo* aiv6;
! 617: #endif /* DO_MINUS_SP */
! 618:
! 619: sock_family = PF_INET6;
! 620:
! 621: #ifdef DO_MINUS_SP
! 622: (void) memset( (void*) &sa4, 0, sizeof(sa4) );
! 623: if ( inet_pton( AF_INET, server, (void*) &sa4.sin_addr ) == 1 )
! 624: {
! 625: sock_family = PF_INET;
! 626: sa4.sin_port = htons( port );
! 627: sa_len = sizeof(sa4);
! 628: (void) memmove( &sa, &sa4, sa_len );
! 629: }
! 630: else if ( inet_pton( AF_INET6, server, (void*) &sa.sin6_addr ) != 1 )
! 631: {
! 632: #ifdef DO_DNS
! 633: (void) memset( &hints, 0, sizeof(hints) );
! 634: hints.ai_family = PF_UNSPEC;
! 635: hints.ai_socktype = SOCK_STREAM;
! 636: (void) snprintf( portstr, sizeof(portstr), "%d", port );
! 637: if ( (gaierr = getaddrinfo( server, portstr, &hints, &ai )) != 0 )
! 638: {
! 639: (void) fprintf(
! 640: stderr, "%s: getaddrinfo %s - %s\n", argv0, server,
! 641: gai_strerror( gaierr ) );
! 642: exit( 1 );
! 643: }
! 644:
! 645: /* Find the first IPv4 and IPv6 entries. */
! 646: aiv4 = (struct addrinfo*) 0;
! 647: aiv6 = (struct addrinfo*) 0;
! 648: for ( ai2 = ai; ai2 != (struct addrinfo*) 0; ai2 = ai2->ai_next )
! 649: {
! 650: switch ( ai2->ai_family )
! 651: {
! 652: case PF_INET:
! 653: if ( aiv4 == (struct addrinfo*) 0 )
! 654: aiv4 = ai2;
! 655: break;
! 656: case PF_INET6:
! 657: if ( aiv6 == (struct addrinfo*) 0 )
! 658: aiv6 = ai2;
! 659: break;
! 660: }
! 661: }
! 662:
! 663: /* If there's an IPv4 address, use that, otherwise try IPv6. */
! 664: if ( aiv4 != (struct addrinfo*) 0 )
! 665: {
! 666: if ( sizeof(sa) < aiv4->ai_addrlen )
! 667: {
! 668: (void) fprintf(
! 669: stderr, "%s - sockaddr too small (%lu < %lu)\n",
! 670: server, (unsigned long) sizeof(sa),
! 671: (unsigned long) aiv4->ai_addrlen );
! 672: exit( 1 );
! 673: }
! 674: sock_family = aiv4->ai_family;
! 675: sock_type = aiv4->ai_socktype;
! 676: sock_protocol = aiv4->ai_protocol;
! 677: sa_len = aiv4->ai_addrlen;
! 678: (void) memmove( &sa, aiv4->ai_addr, sa_len );
! 679: goto ok;
! 680: }
! 681: if ( aiv6 != (struct addrinfo*) 0 )
! 682: {
! 683: if ( sizeof(sa) < aiv6->ai_addrlen )
! 684: {
! 685: (void) fprintf(
! 686: stderr, "%s - sockaddr too small (%lu < %lu)\n",
! 687: server, (unsigned long) sizeof(sa),
! 688: (unsigned long) aiv6->ai_addrlen );
! 689: exit( 1 );
! 690: }
! 691: sock_family = aiv6->ai_family;
! 692: sock_type = aiv6->ai_socktype;
! 693: sock_protocol = aiv6->ai_protocol;
! 694: sa_len = aiv6->ai_addrlen;
! 695: (void) memmove( &sa, aiv6->ai_addr, sa_len );
! 696: goto ok;
! 697: }
! 698:
! 699: (void) fprintf(
! 700: stderr, "%s: no valid address found for host %s\n", argv0, server );
! 701: exit( 1 );
! 702:
! 703: ok:
! 704: freeaddrinfo( ai );
! 705: #else /* DO_DNS */
! 706: (void) fprintf(
! 707: stderr, "%s: bad server IP address %s\n", argv0, server );
! 708: exit( 1 );
! 709: #endif /* DO_DNS */
! 710: }
! 711: #else /* DO_MINUS_SP */
! 712: sa.sin6_addr = in6addr_any;
! 713: sa.sin6_port = htons( SMTP_PORT );
! 714: #endif /* DO_MINUS_SP */
! 715:
! 716: sa.sin6_family = sock_family;
! 717:
! 718: }
! 719:
! 720: #else /* USE_IPV6 */
! 721:
! 722: {
! 723: #ifdef DO_MINUS_SP
! 724: struct hostent *he;
! 725: #else /* DO_MINUS_SP */
! 726: char local_addr[4] = { 127, 0, 0, 1 };
! 727: #endif /* DO_MINUS_SP */
! 728:
! 729: sock_family = PF_INET;
! 730:
! 731: #ifdef DO_MINUS_SP
! 732: sa.sin_addr.s_addr = inet_addr( server );
! 733: sa.sin_port = htons( port );
! 734: if ( (int32_t) sa.sin_addr.s_addr == -1 )
! 735: {
! 736: #ifdef DO_DNS
! 737: he = gethostbyname( server );
! 738: if ( he == (struct hostent*) 0 )
! 739: {
! 740: (void) fprintf(
! 741: stderr, "%s: server name lookup of '%s' failed - %s\n",
! 742: argv0, server, hstrerror( h_errno ) );
! 743: exit( 1 );
! 744: }
! 745: sock_family = he->h_addrtype;
! 746: (void) memmove( &sa.sin_addr, he->h_addr, he->h_length );
! 747: #else /* DO_DNS */
! 748: (void) fprintf(
! 749: stderr, "%s: bad server IP address %s\n", argv0, server );
! 750: exit( 1 );
! 751: #endif /* DO_DNS */
! 752: }
! 753: #else /* DO_MINUS_SP */
! 754: (void) memmove( &sa.sin_addr, local_addr, sizeof(local_addr) );
! 755: sa.sin_port = htons( SMTP_PORT );
! 756: #endif /* DO_MINUS_SP */
! 757:
! 758: sa.sin_family = sock_family;
! 759: }
! 760:
! 761: #endif /* USE_IPV6 */
! 762:
! 763: sockfd = socket( sock_family, sock_type, sock_protocol );
! 764: if ( sockfd < 0 )
! 765: show_error( "socket" );
! 766:
! 767: if ( connect( sockfd, (struct sockaddr*) &sa, sa_len ) < 0 )
! 768: show_error( "connect" );
! 769:
! 770: return sockfd;
! 771: }
! 772:
! 773:
! 774: static int
! 775: read_response( void )
! 776: {
! 777: char buf[10000];
! 778: char* cp;
! 779: int status;
! 780:
! 781: for (;;)
! 782: {
! 783: (void) alarm( timeout );
! 784: if ( fgets( buf, sizeof(buf), sockrfp ) == (char*) 0 )
! 785: {
! 786: (void) fprintf( stderr, "%s: unexpected EOF\n", argv0 );
! 787: exit( 1 );
! 788: }
! 789: if ( verbose )
! 790: (void) fprintf( stderr, "<<<< %s", buf );
! 791: for ( status = 0, cp = buf; *cp >= '0' && *cp <= '9'; ++cp )
! 792: status = 10 * status + ( *cp - '0' );
! 793: if ( *cp == ' ' )
! 794: break;
! 795: if ( *cp != '-' )
! 796: {
! 797: (void) fprintf(
! 798: stderr, "%s: bogus reply syntax - '%s'\n", argv0, buf );
! 799: exit( 1 );
! 800: }
! 801: }
! 802: return status;
! 803: }
! 804:
! 805:
! 806: static void
! 807: send_command( char* command )
! 808: {
! 809: (void) alarm( timeout );
! 810: if ( verbose )
! 811: (void) fprintf( stderr, ">>>> %s\n", command );
! 812: (void) fprintf( sockwfp, "%s\r\n", command );
! 813: (void) fflush( sockwfp );
! 814: }
! 815:
! 816:
! 817: static void
! 818: send_data( char* data )
! 819: {
! 820: int bol;
! 821:
! 822: for ( bol = 1; *data != '\0'; ++data )
! 823: {
! 824: if ( bol && *data == '.' )
! 825: putc( '.', sockwfp );
! 826: bol = 0;
! 827: if ( *data == '\n' )
! 828: {
! 829: putc( '\r', sockwfp );
! 830: bol = 1;
! 831: }
! 832: putc( *data, sockwfp );
! 833: }
! 834: if ( ! bol )
! 835: (void) fputs( "\r\n", sockwfp );
! 836: }
! 837:
! 838:
! 839: static void
! 840: send_done( void )
! 841: {
! 842: (void) fputs( ".\r\n", sockwfp );
! 843: (void) fflush( sockwfp );
! 844: }
! 845:
! 846:
! 847: static void
! 848: sigcatch( int sig )
! 849: {
! 850: (void) fprintf( stderr, "%s: timed out\n", argv0 );
! 851: exit( 1 );
! 852: }
! 853:
! 854:
! 855: static void
! 856: show_error( char* cause )
! 857: {
! 858: char buf[5000];
! 859:
! 860: (void) snprintf( buf, sizeof(buf), "%s: %s", argv0, cause );
! 861: perror( buf );
! 862: exit( 1 );
! 863: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mini_sendmail.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mini_sendmail