开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机短信编程 > 查看源码
smsd.c
资源名称：sms_client-2.0.7k.tgz　[点击查看]
上传用户：mei_mei897
上传日期：2007-01-05
资源大小：82k
文件大小：19k
源码类别：

手机短信编程

开发平台：

Unix_Linux

smsd.c：源码内容
  1. /* -------------------------------------------------------------------- */
  2. /* SMS Client, send messages to mobile phones and pagers */
  3. /* */
  4. /* smsd.c */
  5. /* */
  6. /*  Copyright (C) 1997,1998 Angelo Masci */
  7. /* */
  8. /*  This library is free software; you can redistribute it and/or */
  9. /*  modify it under the terms of the GNU Library General Public */
  10. /*  License as published by the Free Software Foundation; either */
  11. /*  version 2 of the License, or (at your option) any later version. */
  12. /* */
  13. /*  This library is distributed in the hope that it will be useful, */
  14. /*  but WITHOUT ANY WARRANTY; without even the implied warranty of */
  15. /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
  16. /*  Library General Public License for more details. */
  17. /* */
  18. /*  You should have received a copy of the GNU Library General Public */
  19. /*  License along with this library; if not, write to the Free */
  20. /*  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  21. /* */
  22. /*  You can contact the author at this e-mail address: */
  23. /* */
  24. /*  angelo@styx.demon.co.uk */
  25. /* */
  26. /* --------------------------------------------------------------------
  27.    $Id$
  28.    -------------------------------------------------------------------- */
  30. #include <stdio.h>
  31. #include <stdlib.h>
  32. #include <string.h>
  33. #include <ctype.h>
  34. #include <sys/types.h>
  35. #include <sys/socket.h>
  36. #include <sys/stat.h>
  37. #include <fcntl.h>
  38. #include <unistd.h>
  39. #include <errno.h>
  41. #if !defined(AIX) && !defined(SOLARIS) && !defined(UNIXWARE)
  42. #include <getopt.h>
  43. #endif
  45. #include "server.h"
  46. #include "logfile.h"
  47. #include "common.h"
  49. /* -------------------------------------------------------------------- */
  51. #if !defined(MSMSDLOGFILE)
  52. #error "MSMSDLOGFILE undefined"
  53. #else
  54. #define LOGFILE         MSMSDLOGFILE
  55. #endif
  57. #if !defined(MSMSDLOGLEVEL)
  58. #error "MSMSDLOGLEVEL undefined" 
  59. #else
  60. #define LOGLEVEL MSMSDLOGLEVEL
  61. #endif
  63. /* -------------------------------------------------------------------- */
  65. #define SMS_PORT 4563 /* Standard port number  */
  66. /* assigned for sms traffic */
  68. #define SMS_SPOOLDIR "/var/spool/sms"
  69. #define SMS_INCOMINGDIR "incoming"
  70. #define SMS_SERVICESDIR "services"
  72. #define SMS_MAXID 32000
  74. /* -------------------------------------------------------------------- */
  76. #define ERROR_STATE -2
  77. #define EXIT_STATE -1
  78. #define NULL_STATE  0
  79. #define UNKNOWN_STATE  1
  81. /* -------------------------------------------------------------------- */
  83. struct sms_control_data_struct
  84. {
  85. char  *user,
  86. *host,
  87. *mail,
  88. *alen,
  89. *destination,
  90. *control_file,
  91. *data_file,
  92. *id;
  94. long len;
  96. };
  98. typedef struct sms_control_data_struct SMS_CONTROL_DATA;
  100. struct sms_data_struct
  101. {
  102. char  *data;
  103. };
  105. typedef struct sms_data_struct SMS_DATA;
  107. /* -------------------------------------------------------------------- */
  109. SMS_DATA sms_data;
  111. /* -------------------------------------------------------------------- */
  113. #define SAFEOUTPUT(X) ((X == NULL)?("<NULL>"):(X))
  114. #define SAFECONTROLOUTPUT(X) ((X == NULL)?(""):(X))
  116. /* -------------------------------------------------------------------- */
  118. void cleanup_files(SMS_CONTROL_DATA *control_data);
  119. void display_current(int fd, SMS_CONTROL_DATA *control_data);
  120. char *get_data(char *buf);
  121. int gen_controlfile(SMS_CONTROL_DATA *control_data);
  122. void gateway(int new_fd);
  123. int copy_data(int dst_fd, int src_fd, long dlen);
  124. void usage(char *file);
  126. /* -------------------------------------------------------------------- */
  127. /* -------------------------------------------------------------------- */
  128. void display_current(int fd, SMS_CONTROL_DATA *control_data)
  129. {
  130. hprintf(fd, "     Current Control Record info:rn");
  131. hprintf(fd, "         Username: %srn", SAFEOUTPUT(control_data->user));
  132. hprintf(fd, "         Hostname: %srn", SAFEOUTPUT(control_data->host));
  133. hprintf(fd, "         Mail on Delivery: %srn", SAFEOUTPUT(control_data->mail));
  134. hprintf(fd, "         Destination: %srn", SAFEOUTPUT(control_data->destination));
  135. hprintf(fd, "         Control File: %srn", SAFEOUTPUT(control_data->control_file));
  136. hprintf(fd, "         Data File: %srn", SAFEOUTPUT(control_data->data_file));
  137. hprintf(fd, "         ID: %srn", SAFEOUTPUT(control_data->id));
  138. hprintf(fd, "         Length: %ldrn", control_data->len);
  139. }
  142. /* -------------------------------------------------------------------- */
  143. /* -------------------------------------------------------------------- */
  144. void write_control_data(SMS_CONTROL_DATA *control_data)
  145. {
  146. FILE *fp;
  149. fp = fopen(control_data->control_file, "w");
  150. if (fp == NULL)
  151. { lprintf(LOG_ERROR, "opening control_file %sn", control_data->control_file);
  152. exit(-1);
  153. }
  156. fprintf(fp, "{n");
  157. fprintf(fp, "tUsername         = "%s";n", SAFECONTROLOUTPUT(control_data->user));
  158. fprintf(fp, "tHostname         = "%s";n", SAFECONTROLOUTPUT(control_data->host));
  159. fprintf(fp, "tMail_on_Delivery = "%s";n", SAFECONTROLOUTPUT(control_data->mail));
  160. fprintf(fp, "tDestination      = "%s";n", SAFECONTROLOUTPUT(control_data->destination));
  161. fprintf(fp, "tControl_File     = "%s";n", SAFECONTROLOUTPUT(control_data->control_file));
  162. fprintf(fp, "tData_File        = "%s";n", SAFECONTROLOUTPUT(control_data->data_file));
  163. fprintf(fp, "tID               = "%s";n", SAFECONTROLOUTPUT(control_data->id));
  164. fprintf(fp, "tLength           = "%ld"n";, control_data->len);
  165. fprintf(fp, "}n");
  167. fclose(fp);
  168. }
  170. /* -------------------------------------------------------------------- */
  171. /* Parse string of form: */
  172. /* */
  173. /* COMMAND<SP>DATA<EOL> */
  174. /*  */
  175. /* Copy data to newly allocated buffer and return */
  176. /* a pointer to it. If no data available return NULL */
  177. /* -------------------------------------------------------------------- */
  178. char *get_data(char *buf)
  179. {
  180. char  *src, 
  181. *dst,
  182. *data;
  183. int i, j,
  184. cmd;
  187. cmd = TRUE;
  188. src = buf;
  189. i   = 0;
  190. j   = 0;
  191. while ((*src != 'n') && (*src != '') && (*src != 'r'))
  192. {
  193. if ((cmd) && (*src == ' '))
  194. { cmd = FALSE;
  195. j = i+1;
  196. i = 0;
  197. } 
  198. else
  199. { i++;
  200. }
  202. src++;
  203. }
  205. #if 0
  206. if ((j == 0) ||
  207.     ((i == 1) && ((*src == 'n') || (*src == 'r') || (isspace(*src)) || (*src == ''))))
  208. { return NULL;
  209. }
  210. #else
  211. if (j == 0)
  212. { return NULL;
  213. }
  214. #endif
  216. data = (char *)malloc(sizeof(char) * i + 1);
  217. if (dst == NULL)
  218. { lprintf(LOG_ERROR, "Allocating memoryn");
  219. exit(-1);
  220. }
  222. dst = data;
  223. src = &buf[j];
  224. while ((*src != 'n') && (*src != '') && (*src != 'r'))
  225. {
  226. *dst++ = *src++;
  227. }
  229. *dst = '';
  230. return data;
  231. }
  233. int is_complete(SMS_CONTROL_DATA *control_data)
  234. {
  235. if ((control_data->user == NULL) ||
  236.     (control_data->host == NULL) ||
  237.     (control_data->mail == NULL) ||
  238.     (control_data->alen == NULL) ||
  239.     (control_data->id   == NULL) ||
  240.     (control_data->destination  == NULL) ||
  241.     (control_data->control_file == NULL) ||
  242.     (control_data->data_file    == NULL))
  243. {
  244. return 0;
  245. }
  247. return 1;
  248. }
  251. /* -------------------------------------------------------------------- */
  252. /* -------------------------------------------------------------------- */
  253. SMS_CONTROL_DATA *init_control_data(void)
  254. {
  255. SMS_CONTROL_DATA
  256. *control_data;
  259. control_data = (SMS_CONTROL_DATA *)malloc(sizeof(SMS_CONTROL_DATA));
  260. if (control_data == NULL)
  261. { lprintf(LOG_ERROR, "Allocating memoryn");
  262. exit(-1);
  263. }
  265. control_data->user = NULL;
  266. control_data->host = NULL;
  267. control_data->mail = NULL;
  268. control_data->alen = NULL;
  269. control_data->id   = NULL;
  271. control_data->destination  = NULL;
  272. control_data->control_file = NULL;
  273. control_data->data_file    = NULL;
  275. control_data->len = 0;
  277. return control_data;
  278. }
  281. /* -------------------------------------------------------------------- */
  282. /* Generate a control file in the incoming directory.  */
  283. /* The control file is empty.  */
  284. /* The control_data structure is updated to include the full path */
  285. /* to the generated control file and it's corresponding data file. */
  286. /* Note that memory is allocated for each of control_file,  */
  287. /* data_file and id. It is the responsibility of the caller to */
  288. /* free this memory. */
  289. /* */
  290. /* Return Value: */
  291. /* */
  292. /* -1 error */
  293. /*   0 Success */
  294. /* -------------------------------------------------------------------- */
  295. int gen_controlfile(SMS_CONTROL_DATA *control_data)
  296. {
  297. int n,
  298. fd;
  301. cleanup_files(control_data);
  304. control_data->id = (char *)malloc(sizeof(char) * 8);
  305. if (control_data->id == NULL)
  306. {
  307. lprintf(LOG_ERROR, "Allocating memoryn");
  308. exit(-1);
  309. }
  311. control_data->control_file = (char *)malloc(sizeof(char) * (sms_strlen(SMS_SPOOLDIR) + 
  312.                                             sms_strlen(SMS_INCOMINGDIR) + 10));
  313. if (control_data->control_file == NULL)
  314. {
  315. lprintf(LOG_ERROR, "Allocating memoryn");
  316. exit(-1);
  317. }
  319. control_data->data_file = (char *)malloc(sizeof(char) * (sms_strlen(SMS_SPOOLDIR) + 
  320.                                          sms_strlen(SMS_INCOMINGDIR) + 10));
  321. if (control_data->data_file == NULL)
  322. {
  323. lprintf(LOG_ERROR, "Allocating memoryn");
  324. exit(-1);
  325. }
  327.    sms_strcpy(control_data->control_file, SMS_SPOOLDIR);
  328.    sms_strcpy(control_data->data_file, SMS_SPOOLDIR);
  330. if (control_data->control_file[sms_strlen(control_data->control_file) -1] != '/')
  331. {
  332. sms_strcat(control_data->data_file, "/");
  333. sms_strcat(control_data->control_file, "/");
  334. }
  336. sms_strcat(control_data->control_file, SMS_INCOMINGDIR);
  337. sms_strcat(control_data->data_file, SMS_INCOMINGDIR);
  339. if (control_data->control_file[sms_strlen(control_data->control_file) -1] != '/')
  340. {
  341. sms_strcat(control_data->data_file, "/");
  342. sms_strcat(control_data->control_file, "/");
  343. }
  347. for (n = getpid(); n < SMS_MAXID; n++)
  348. {
  349. sprintf(control_data->id, "%05d", n);
  350. sprintf(control_data->control_file, "%scf%s", control_data->control_file, control_data->id);
  351. sprintf(control_data->data_file, "%sdf%s", control_data->data_file, control_data->id);
  353. if (access(control_data->control_file, F_OK) == 0)
  354. { continue;
  355. }
  356. else
  357. { fd = open(control_data->control_file, O_CREAT|O_WRONLY|O_EXCL, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
  358. if (fd == -1)
  359. { if (errno == EEXIST)
  360. { continue;
  361. }
  363. lprintf(LOG_WARNING, "Cannot create file %sn", control_data->control_file);
  365. free(control_data->control_file);
  366. free(control_data->data_file);
  367. free(control_data->id);
  369. return -1;
  370. }
  371. else
  372. { close(fd);
  373. break;
  374. }
  376. }
  377. }
  379. if (n == SMS_MAXID)
  380. { lprintf(LOG_WARNING, "Cannot create file as MAXID exceededn");
  382. free(control_data->control_file);
  383. free(control_data->data_file);
  384. free(control_data->id);
  386. return -1;
  387. }
  389. return 0;
  390. }
  393. /* -------------------------------------------------------------------- */
  394. /* -------------------------------------------------------------------- */
  395. void cleanup_files(SMS_CONTROL_DATA *control_data)
  396. {
  397. if (control_data->control_file != NULL)
  398. {
  399. unlink(control_data->control_file);
  401. free(control_data->control_file);
  402. control_data->control_file = NULL;
  403. }
  405. if (control_data->data_file != NULL)
  406. {
  407. unlink(control_data->data_file);
  409. free(control_data->data_file);
  410. control_data->data_file = NULL;
  411. }
  413. if (control_data->id != NULL)
  414. {
  415. free(control_data->id);
  416. control_data->id = NULL;
  417. }
  418. }
  421. /* -------------------------------------------------------------------- */
  422. /* -------------------------------------------------------------------- */
  423. void gateway(int new_fd)
  424. {
  425. char buf[MAX_STRING_LEN],
  426. host_name[512],
  427. ip_address[512];
  429. int  state, 
  430. data_fd;
  432. SMS_CONTROL_DATA
  433. *control_data;
  436. control_data = init_control_data();
  440. if (get_client_information(new_fd, host_name, ip_address) == 0)
  441. { lprintf(LOG_STANDARD, "Connection from %s [%s]n", host_name, ip_address);
  442. }
  444. hprintf(new_fd, "400 SMS Gateway Readyrn");
  446. while ((state != EXIT_STATE) &&
  447.        (state != ERROR_STATE) &&
  448.        (hgets(buf, MAX_STRING_LEN, new_fd) != NULL))
  449. {
  450. state = NULL_STATE;
  452. if (strncasecmp(buf, "MAIL", 4) == 0)
  453. {
  454. control_data->mail = get_data(buf);
  455. if (control_data->mail == NULL)
  456. { state = ERROR_STATE;
  457. }
  458. }
  459. else if (strncasecmp(buf, "HOST", 4) == 0)
  460. {
  461. control_data->host = get_data(buf);
  462. if (control_data->host == NULL)
  463. { state = ERROR_STATE;
  464. }
  465. }
  466. else if (strncasecmp(buf, "DEST", 4) == 0)
  467. {
  468. control_data->destination = get_data(buf);
  469. if (control_data->destination == NULL)
  470. { state = ERROR_STATE;
  471. }
  472. }
  473. else if (strncasecmp(buf, "DATA", 4) == 0)
  474. {
  476. control_data->alen = get_data(buf);
  477. if (control_data->alen == NULL)
  478. { state = ERROR_STATE;
  479. }
  480. else
  481. { control_data->len = atoi(control_data->alen);
  483. /* WARNING - use strtol and strict  */
  484. /* checks  */
  486. /* Read 'len' bytes of data from fd */
  487. /* and copy to data_file */
  489. /* Open up the data_file -  */
  490. /* ensure we have a control file and    */
  491. /* all locks are setup */
  493. if (gen_controlfile(control_data) == -1)
  494. { state = ERROR_STATE;
  495. }
  496. else
  497. {
  498. data_fd = open(control_data->data_file, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
  499. if (data_fd < 0)
  500. { lprintf(LOG_ERROR, "opening data_file %sn", control_data->data_file);
  501. exit(-1);
  502. }
  504. if (copy_data(data_fd, new_fd, control_data->len) != 0)
  505. { lprintf(LOG_ERROR, "copying datan");
  506. exit(-1);
  507. }
  509. close(data_fd);
  511. read(new_fd, &buf[0], 1);
  512. if (buf[0] == 'n')
  513. {
  514. }
  515. else if (buf[0] == 'r')
  516. {
  517. read(new_fd, &buf[0], 1);
  518. if (buf[0] == 'n')
  519. {
  520. }
  521. else
  522. { state = ERROR_STATE;
  523. }
  524. }
  525. else
  526. { state = ERROR_STATE;
  527. }
  528. }
  529. }
  530. }
  531. else if (strncasecmp(buf, "USER", 4) == 0)
  532. {
  533. control_data->user = get_data(buf);
  534. if (control_data->user == NULL)
  535. { state = ERROR_STATE;
  536. }
  537. }
  538. else if (strncasecmp(buf, "SEND", 4) == 0)
  539. {
  540. if (is_complete(control_data))
  541. {
  542. write_control_data(control_data);
  543. }
  544. else
  545. { state = ERROR_STATE;
  546. }
  547. }
  548. else if (strncasecmp(buf, "SENJ", 4) == 0)
  549. {
  550. if (is_complete(control_data))
  551. {
  552. write_control_data(control_data);
  553. }
  554. else
  555. { state = ERROR_STATE;
  556. }
  557. }
  558. else if (strncasecmp(buf, "SENQ", 4) == 0)
  559. {
  560. if (is_complete(control_data))
  561. {
  562. write_control_data(control_data);
  563. }
  564. else
  565. { state = ERROR_STATE;
  566. }
  567. }
  568. else if (strncasecmp(buf, "SENA", 4) == 0)
  569. {
  570. if (is_complete(control_data))
  571. {
  572. write_control_data(control_data);
  573. }
  574. else
  575. { state = ERROR_STATE;
  576. }
  577. }
  578. else if (strncasecmp(buf, "STAJ", 4) == 0)
  579. {
  580. }
  581. else if (strncasecmp(buf, "STAQ", 4) == 0)
  582. {
  583. }
  584. else if (strncasecmp(buf, "STAT", 4) == 0)
  585. {
  586. }
  587. else if (strncasecmp(buf, "INFO", 4) == 0)
  588. {
  589. if (((buf[4] == 'r') && (buf[5] == 'n')) ||
  590.      (buf[4] == 'n'))
  591. {
  592. hprintf(new_fd, "231- SMS Server info:rn");
  593. hprintf(new_fd, "         Version: 0.1rn");
  595. display_current(new_fd, control_data);
  597. hprintf(new_fd, "231 End of Info.rn");
  598. continue;
  599. }
  600. else
  601. {
  602. }
  603. }
  604. else if (strncasecmp(buf, "QUIT", 4) == 0)
  605. {
  606. hprintf(new_fd, "220 Goodbye.rn");
  607. state = EXIT_STATE;
  608. continue;
  609. }
  610. else if (strncasecmp(buf, "HELP", 4) == 0)
  611. {
  612. if (((buf[4] == 'r') && (buf[5] == 'n')) ||
  613.      (buf[4] == 'n'))
  614. {
  615. hprintf(new_fd, "230- The following commands are recognizedrn");
  616. hprintf(new_fd, "     USER    DATA    MAIL    HOST    DESTrn");
  617. hprintf(new_fd, "     SEND    SENJ    SENQ    SENA        rn");
  618. hprintf(new_fd, "     STAT    STAJ    STAQ                rn");
  619. hprintf(new_fd, "     QUIT    INFO    HELP                rn");
  620. hprintf(new_fd, "230 End of Help.rn");
  621. continue;
  622. }
  623. else
  624. {
  625. }
  626. }
  627. else 
  628. { state = UNKNOWN_STATE;
  629. }
  631. if (state == ERROR_STATE)
  632. { hprintf(new_fd, "510 Error Connection Terminated.rn");
  633. }
  634. else if (state == UNKNOWN_STATE)
  635. { hprintf(new_fd, "511 Error Command not understood.rn");
  636. }
  637. else
  638. { hprintf(new_fd, "210 Ok.rn");
  639. }
  640. }
  642. if (state == ERROR_STATE)
  643. { cleanup_files(control_data);
  644. }
  646. free(control_data);
  647. }
  650. /* -------------------------------------------------------------------- */
  651. /* Read 'len' bytes of data from src_fd and copy to 'dst_fd'  */
  652. /* Return Values */
  653. /* */
  654. /*  0 Success */
  655. /*  -1 Failure */
  656. /* -------------------------------------------------------------------- */
  657. int copy_data(int dst_fd, int src_fd, long dlen)
  658. {
  659. int  len, 
  660. sent;
  662. char *ptr;
  663. char *mbuf;
  666. mbuf = (char *)malloc(sizeof(char) * 1024);
  667. if (mbuf == NULL)
  668. { lprintf(LOG_ERROR, "Allocating memoryn");
  669. exit(-1);
  670. }
  672. {
  673. len = read(src_fd, mbuf, ((dlen<1024)?(dlen):(1024)));
  674. if (len < 0)
  675. { if (errno != EINTR)
  676. { lprintf(LOG_ERROR, "readn");
  677. return(-1);
  678. }
  679. }
  681. } while (len < 0);
  684. while(len)
  685. {
  686. dlen -= len;
  688. ptr = mbuf;
  689. sent = 0;
  690. while (len - sent)
  691. {
  692. len -= sent;
  693. ptr += sent;
  695. {
  696. sent = write(dst_fd, ptr, len);
  697. if (sent < 0)
  698. { if (errno != EINTR)
  699. { lprintf(LOG_ERROR, "write");
  700. return(-1);
  701. }
  702. }
  704. } while (len < 0);
  706. if (sent == 0)
  707. { lprintf(LOG_ERROR, "writen");
  708. return(-1);
  709. }
  710. }
  712. if (dlen <= 0)
  713. { break;
  714. }
  716. {
  717. len = read(src_fd, mbuf, ((dlen<1024)?(dlen):(1024)));
  718. if (len < 0)
  719. { if (errno != EINTR)
  720. { lprintf(LOG_ERROR, "read");
  721. return(-1);
  722. }
  723. }
  725. } while (len < 0);
  726. }
  728. free(mbuf);
  729. return 0;
  730. }
  733. /* -------------------------------------------------------------------- */
  734. /* -------------------------------------------------------------------- */
  735. void usage(char *file)
  736. {
  737. lprintf(LOG_STANDARD, "Usage: %s [-l loglevel] [-p port]n", file);
  738. }
  740. /* -------------------------------------------------------------------- */
  741. /* -------------------------------------------------------------------- */
  742. int main(int argc, char *argv[])
  743. {
  744. int  c,
  745. port;
  746. char *ptr;
  748. struct  sockaddr 
  749. sa_client;
  752. /* ---------------------------- */
  754. set_logfile(LOGFILE);
  755. set_loglevel(LOGLEVEL);
  756. set_consolelog(TRUE);
  758. /* ---------------------------- */
  760. port = SMS_PORT;
  762. while ((c = getopt (argc, argv, "p:l:")) != -1)
  763.         {
  764.                 switch (c)
  765.                 {
  766.                         case 'p':  
  767. port = (int)strtol(optarg, &ptr, 10);
  768.                                 break;
  770.                         case 'l':  
  771. set_loglevel((int)strtol(optarg, &ptr, 10));
  772. if (ptr == optarg)
  773. {
  774. lprintf(LOG_ERROR, "Option l requires an argumentn");
  775.                               usage(argv[0]);
  776.                                  exit(-1);
  777. }
  778.                                 
  779.                                 break;
  781.                         case '?':
  782.                                 lprintf(LOG_ERROR, "Unknown option `-%c'n", optopt);
  783.                                 usage(argv[0]);
  784.                                 exit(-1);
  786.                         default:
  787.                                 abort ();
  788.                 }
  789.         }
  791. if ((argc - optind) != 0)
  792. { usage(argv[0]);
  793. exit(-1);
  794. }
  796. /* ---------------------------- */
  798. c = sizeof(sa_client);
  799. if (getpeername(fileno(stdin), &sa_client, &c) < 0)
  800. {
  801. /* getpeername() fails if fd isn't a  */
  802. /* socket. If this is the case we can  */
  803. /* assume that we aren't running */
  804. /* from inetd and should startup and */
  805. /* as and run as a daemon ourselves. */
  808. lprintf(LOG_STANDARD, "Starting SMSD Standalone Server deamon...n");
  810. if (server_main(port, gateway) != 0)
  811. { lprintf(LOG_STANDARD, "Failed to start SMSD Standalone Server deamonn");
  812. exit(-1);
  813. }
  814. }
  815. else
  816. { set_consolelog(FALSE);
  817. lprintf(LOG_STANDARD, "Starting SMSD Server as an INETD servicen");
  818. gateway(fileno(stdin));
  819. }
  821. return 0;
  822. }