libsms_modem.c

Go to the documentation of this file.

/*
SMS Server Tools
Copyright (C) 2000 Stefan Frings

This program is free software unless you got it under another license directly
from the author. You can redistribute it and/or modify it under the terms of
the GNU General Public License as published by the Free Software Foundation.
Either version 2 of the License, or (at your option) any later version.

http://www.isis.de/members/~s.frings
mailto:s.frings@mail.isis.de
 */


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <termios.h>
#include <stdio.h>
#include <unistd.h>
#include <syslog.h>
#include <sys/ioctl.h>
#ifdef __sun
#include <sys/filio.h>
#endif
#include "libsms_modem.h"
#include "../../dprint.h"

#define  MAX_BUF        2048
#define  CDS_HDR        "\r\n+CDS:"
#define  CDS_HDR_LEN    (strlen(CDS_HDR))
#define optz(_n,_l)     (buf+buf_len-(((_n)+(_l)>buf_len)?buf_len:(_n)+(_l)))

/* global variables */
int         sms_report_type;
cds_report  cds_report_func;



int put_command( struct modem *mdm, char* cmd, int cmd_len, char* answer,
                                 int max, int timeout,char* exp_end)
{
   static char buf[MAX_BUF];
   static int  buf_len = 0;
   char* pos;
   char* foo;
   char* ptr;
   char* to_move;
   char* answer_s;
   char* answer_e;
   int   timeoutcounter;
   int   available;
   int   status;
   int   exp_end_len;
   int   n;

   /* check if fd is "clean" for reading */
   timeoutcounter = 0;
   ioctl(mdm->fd,TIOCMGET,&status);
   while (!(status & TIOCM_CTS))
   {
      usleep( READ_SLEEP );
      timeoutcounter++;
      ioctl(mdm->fd,TIOCMGET,&status);
      if (timeoutcounter>=timeout) {
         LM_INFO("Modem is not clear to send\n");
         return 0;
      }
   }
#ifdef SHOW_SMS_MODEM_COMMAND
   LM_DBG("<--<%d>-->[%.*s] \n",cmd_len,cmd_len,cmd);
#endif
   /* send the command to the modem */
   write(mdm->fd,cmd,cmd_len);
   tcdrain(mdm->fd);

   /* read from the modem */
   exp_end_len = exp_end?strlen(exp_end):0;
   answer_s = buf;
   answer_e = 0;
   to_move = 0;
   do
   {
      /* try to read some bytes */
      ioctl(mdm->fd,FIONREAD,&available);
      /* how many bytes are available to read? */
      if (available<1)  /* if 0 then wait a little bit and retry */
      {
         usleep( READ_SLEEP );
         timeoutcounter++;
         ioctl(mdm->fd,FIONREAD,&available);
      }
      if (available>0)
      {
         /* How many bytes do I want to read maximum?
         Not more than buffer size. And how many bytes are available? */
         n = (available>MAX_BUF-buf_len-1)?MAX_BUF-buf_len-1:available;
         /* read data */
         n = read( mdm->fd, buf+buf_len, n);
         if (n<0) {
            LM_ERR("error reading from modem: %s\n",
               strerror(errno));
            goto error;
         }
         if (n) {
            buf_len += n;
            buf[buf_len] = 0;
            //LM_DBG("read = [%s]\n",buf+buf_len-n);
            foo = pos = 0;
            if ( (!exp_end && ((pos=strstr(optz(n,4),"OK\r\n"))
            || (foo=strstr(optz(n,5),"ERROR"))))
            || (exp_end && (pos=strstr(optz(n,exp_end_len),exp_end)) )) {
               /* we found the end */
               //LM_DBG("end found = %s\n",
               // (foo?"ERROR":(exp_end?exp_end:"OK")));
               /* for ERROR we still have to read EOL */
               if (!foo || (foo=strstr(foo+5,"\r\n"))) {
                  answer_e = foo?foo+2:(pos+(exp_end?exp_end_len:4));
                  timeoutcounter = timeout;
               }
            }
         }
      }
   /* repeat until timout */
   }while (timeoutcounter<timeout);

   if (!answer_e)
      answer_e = buf+buf_len;

   /* CDS report is activ? */
   if (sms_report_type==CDS_REPORT) {
      to_move = 0;
      ptr = buf;
      /* do we have a CDS reply inside? */
      while ( (pos=strstr(ptr,CDS_HDR)) ) {
         if (pos!=ptr) {  /* here we have the command response */
            answer_s = ptr;
         }
         /* look for the end of CDS response */
         ptr = pos+CDS_HDR_LEN;
         for( n=0 ; n<2&&(foo=strstr(ptr,"\r\n")) ; ptr=foo+2,n++ );
         if (n<2) { /* we haven't read the entire CDS response */
            LM_DBG("CDS end not found!\n");
            to_move = pos;
            ptr = buf + buf_len;
         }else{
            /* process the CDS */
            LM_DBG("CDS=[%.*s]\n",(int)(ptr-pos),pos);
            cds_report_func(mdm,pos,ptr-pos);
         }
      }
      if ((*ptr)) {
         answer_s = ptr;
         ptr = answer_e;
      }
      if (ptr!=buf+buf_len)
         to_move = ptr;
   }

   /* copy the response in answer buffer - as much as fits */
   if (answer && max) {
      n = max-1<answer_e-answer_s?max-1:answer_e-answer_s;
      memcpy(answer,answer_s,n);
      answer[n] = 0;
   }
   /* shift left the remaining data into the buffer - if needs */
   if (sms_report_type==CDS_REPORT && to_move) {
      buf_len = buf_len - (to_move-buf);
      memcpy(buf,to_move,buf_len);
      buf[buf_len] = 0;
      LM_DBG("buffer shifted left=[%d][%s]\n",buf_len,buf);
   } else {
      buf_len = 0;
   }

#ifdef SHOW_SMS_MODEM_COMMAND
   LM_DBG("<-[%s] \n",answer);
#endif
   return answer_e-answer_s;

error:
   return 0;
}




/* setup serial port */
int setmodemparams( struct modem *mdm )
{
   struct termios newtio;

   bzero(&newtio, sizeof(newtio));
   newtio.c_cflag = mdm->baudrate | CRTSCTS | CS8 | CLOCAL | CREAD | O_NDELAY;
   //uncomment next line to disable hardware handshake
   //newtio.c_cflag &= ~CRTSCTS;
   newtio.c_iflag = IGNPAR;
   newtio.c_oflag = 0;
   newtio.c_lflag = 0;
   newtio.c_cc[VTIME]    = 1;
   newtio.c_cc[VMIN]     = 0;
   tcflush(mdm->fd, TCIOFLUSH);
   tcsetattr(mdm->fd,TCSANOW,&newtio);
   return 0;
}




int initmodem(struct modem *mdm, cds_report cds_report_f)
{
   char command[100];
   char answer[100];
   int retries=0;
   int success=0;
   int clen=0;
   int n;

   LM_INFO("init modem %s on %s.\n",mdm->name,mdm->device);

   if (mdm->pin[0]) {
      /* Checking if modem needs PIN */
      put_command(mdm,"AT+CPIN?\r",9,answer,sizeof(answer),50,0);
      if (strstr(answer,"+CPIN: SIM PIN")) {
         LM_INFO("Modem needs PIN, entering PIN...\n");
         clen=sprintf(command,"AT+CPIN=\"%s\"\r",mdm->pin);
         put_command(mdm,command,clen,answer,sizeof(answer),100,0);
         put_command(mdm,"AT+CPIN?\r",9,answer,sizeof(answer),50,0);
         if (!strstr(answer,"+CPIN: READY")) {
            if (strstr(answer,"+CPIN: SIM PIN")) {
               LM_ERR("Modem did not accept this PIN\n");
               goto error;
            } else if (strstr(answer,"+CPIN: SIM PUK")) {
               LM_ERR("YourPIN is locked! Unlock it manually!\n");
               goto error;
            } else {
               goto error;
            }
         }
         LM_INFO("INFO:initmodem: PIN Ready!\n");
         sleep(5);
      }
   }

   if (mdm->mode==MODE_DIGICOM)
      success=1;
   else {
      LM_INFO("INFO:initmodem: Checking if Modem is registered to"
         " the network\n");
      success=0;
      retries=0;
      do
      {
         retries++;
         put_command(mdm,"AT+CREG?\r",9,answer,sizeof(answer),100,0);
         if (strchr(answer,'1') )
         {
            LM_INFO("INFO:initmodem: Modem is registered to the"
               " network\n");
            success=1;
         } else if (strchr(answer,'2')) {
            // added by bogdan
            LM_WARN("Modems seems to try to reach the network!"
                  " Let's wait a little bit\n");
            retries--;
            sleep(2);
         } else if (strchr(answer,'5')) {
            // added by Thomas Stoeckel
            LM_INFO("Modem is registered to a roaming partner network\n");
            success=1;
         } else if (strstr(answer,"ERROR")) {
            LM_WARN("Ignoring that modem does not support +CREG command\n");
            success=1;
         } else {
            LM_NOTICE("NOTICE:initmodem: Waiting 2 sec. before retrying\n");
            sleep(2);
         }
      }while ((success==0)&&(retries<20));
   }

   if (success==0) {
      LM_ERR("Modem is not registered to the network\n");
      goto error;
   }

   for( n=0 ; n<2+2*(sms_report_type==CDS_REPORT) ; n++) {
      /* build the command */
      switch (n) {
         case 0:
            strcpy(command,"AT+CMGF=0\r");
            command[8]+=(mdm->mode==MODE_ASCII || mdm->mode==MODE_DIGICOM);
            clen = 10;
            break;
         case 1:
            strcpy(command,"AT S7=45 S0=0 L1 V1 X4 &c1 E1 Q0\r");
            clen = 33;
            break;
         case 2:
            strcpy(command,"AT+CSMP=49,167,0,241\r");
            clen = 21;
            break;
         case 3:
            strcpy(command,"AT+CNMI=1,1,0,1,0\r");
            clen = 18;
            break;
      }
      /* send it to modem */
      retries=0;
      success=0;
      do {
         retries++;
         /*querying the modem*/
         put_command(mdm,command,clen,answer,sizeof(answer),100,0);
         /*dealing with the answer*/
         if (strstr(answer,"ERROR")) {
            LM_NOTICE("Waiting 1 sec. before to retrying\n");
            sleep(1);
         } else
            success=1;
      }while ((success==0)&&(retries<3));
      /* have we succeeded? */
      if (success==0) {
         LM_ERR("cmd [%.*s] returned ERROR\n", clen-1,command);
         goto error;
      }
   } /* end for */

   if ( sms_report_type==CDS_REPORT && !cds_report_f) {
      LM_ERR("no CDS_REPORT function given\n");
      goto error;
   }
   cds_report_func = cds_report_f;

   if (mdm->smsc[0]) {
      LM_INFO("Changing SMSC to \"%s\"\n",mdm->smsc);
      setsmsc(mdm,mdm->smsc);
   }



   return 0;
error:
   return -1;
}




int checkmodem(struct modem *mdm)
{
   char answer[500];

   /* Checking if modem needs PIN */
   put_command(mdm,"AT+CPIN?\r",9,answer,sizeof(answer),50,0);
   if (!strstr(answer,"+CPIN: READY")) {
      LM_WARN("modem wants the PIN again!\n");
      goto reinit;
   }

   if (mdm->mode!=MODE_DIGICOM) {
      put_command(mdm,"AT+CREG?\r",9,answer,sizeof(answer),100,0);
      if (!strchr(answer,'1') ) {
         LM_WARN("Modem is not registered to the"
               " network\n");
         goto reinit;
      }
   }

   return 1;
reinit:
   LM_WARN("re -init the modem!!\n");
   initmodem(mdm,cds_report_func);
   return -1;
}




int setsmsc(struct modem *mdm, char *smsc)
{
   char command[100];
   char answer[50];
   int  clen;

   if (smsc && smsc[0]) {
      clen=sprintf(command,"AT+CSCA=\"+%s\"\r",smsc);
      put_command(mdm,command,clen,answer,sizeof(answer),50,0);
   }
   return 0;
}




int openmodem( struct modem *mdm)
{
   mdm->fd = open(mdm->device, O_RDWR | O_NOCTTY );
   if (mdm->fd <0)
      return -1;

   tcgetattr(mdm->fd,&(mdm->oldtio));
   return 0;
}




int closemodem(struct modem *mdm)
{
   tcsetattr(mdm->fd,TCSANOW,&(mdm->oldtio));
   close(mdm->fd);
   return 0;
}