gprs.c

Open DMT Client C Source code

const TransportFtns_t *gprs_transportInitialize()
{
    
    /* init transport structure */
    memset(&gprsXport, 0, sizeof(GprsTransport_t));
    gprsXport.type   = TRANSPORT_NONE;
    gprsXport.isOpen = utFalse;
    
    /* init datagram buffer */
    binBuffer(&gprsDatagramBuffer, gprsDatagramData, sizeof(gprsDatagramData), BUFFER_DESTINATION);
    
    /* open bluetree modem */
    blueInitialize();
    blueOpenCom();
    
    /* DEBUG ONLY: test connection */
    //logWARNING(LOGSRC,"Testing Connection ....");
    //bluePowerOnReset = utTrue;
    //blueConnect();

    /* init function structure */
    gprsXportFtns.xportIsOpen       = &gprs_transportIsOpen;
    gprsXportFtns.xportOpen         = &gprs_transportOpen;
    gprsXportFtns.xportClose        = &gprs_transportClose;
    gprsXportFtns.xportReadFlush    = &gprs_transportReadFlush;
    gprsXportFtns.xportReadPacket   = &gprs_transportReadPacket;
    gprsXportFtns.xportWritePacket  = &gprs_transportWritePacket;
    return &gprsXportFtns;

}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

const char *blueGetDataHost()
{
    return propGetString(PROP_COMM_HOST,"");
}

Int16 blueGetDataPort()
{
    return (int)propGetUInt32(PROP_COMM_PORT,0L);
}

const char *blueGetDNS(int ndx)
{
    switch (ndx) {
        case 1: return propGetString(PROP_COMM_DNS_1,"");
        case 2: return propGetString(PROP_COMM_DNS_2,"");
    }
    return DNS_NULL;
}

const char *blueGetApnName()
{
    return propGetString(PROP_COMM_APN_NAME,"");
}

const char *blueGetApnServer()
{
    return propGetString(PROP_COMM_APN_SERVER,"");
}

const char *blueGetApnUser()
{
    return propGetString(PROP_COMM_APN_USER,"");
}

const char *blueGetApnPassword()
{
    return propGetString(PROP_COMM_APN_PASSWORD,"");
}

// ----------------------------------------------------------------------------

#define RESULT_OK_VERBOSE           "OK"
#define RESULT_NOCARRIER_VERBOSE    "NO CARRIER"
#define RESULT_ERROR_VERBOSE        "ERROR"

#define RESULT_GPRS_ACTIVATION      "Ok_Info_GprsActivation"
#define RESULT_TCP_ACTIVATION       "Ok_Info_WaitingForData"
#define RESULT_UDP_ACTIVATION       "Ok_Info_WaitingForData"
#define RESULT_SOCKET_CLOSED        "Ok_Info_SocketClosed"

#define RESULT_CME_ERROR_1          "#CME ERROR:"
#define RESULT_COMMAND_SYNTAX       "#CME ERROR: 34819"
#define RESULT_COMMAND_TOO_LONG     "#CME ERROR: 34881"
#define RESULT_ALREADY_CONNECTED    "#CME ERROR: 35840"
#define RESULT_NOT_REGISTERED       "#CME ERROR: 35865"
#define RESULT_INVALID_EVENT        "#CME ERROR: 35866"
#define RESULT_INACTV_PHYS_LAYER    "#CME ERROR: 35867"
#define RESULT_SERIVCE_RUNNING      "#CME ERROR: 37123"
#define RESULT_OPEN_SESSION_FAILED  "#CME ERROR: 38016"
#define RESULT_DNS_LOOKUP_FAILED    "#CME ERROR: 38027"
#define RESULT_OPEN_GPRS_FAILED     "#CME ERROR: 49155"

#define RESULT_CME_ERROR_2          "+CME ERROR:"
#define RESULT_SIM_NOT_INSERTED     "+CME ERROR: 10"
#define RESULT_SIM_PIN_REQUIRED     "+CME ERROR: 11"
#define RESULT_SIM_PUK_REQUIRED     "+CME ERROR: 12"
#define RESULT_SIM_FAILURE          "+CME ERROR: 13"
#define RESULT_IN_PROGRESS          "+CME ERROR: 515"

static Int32 CME_ERROR(const char *cmeErr) 
{
    if (strStartsWithIgnoreCase(cmeErr, RESULT_CME_ERROR_1)) {
        const char *cme = cmeErr + strlen(RESULT_CME_ERROR_1);
        while (*cme && isspace(*cme)) { cme++; }
        return strParseInt32(cme, 1L);
    } else
    if (strStartsWithIgnoreCase(cmeErr, RESULT_CME_ERROR_2)) {
        const char *cme = cmeErr + strlen(RESULT_CME_ERROR_2);
        while (*cme && isspace(*cme)) { cme++; }
        return strParseInt32(cme, 1L);
    }
    return 0L;
}

// ----------------------------------------------------------------------------

/* error responses */
#define CME_UNKNOWN                         1L     // unknown/unparsable error
#define CME_SIM_NOT_INSERTED               10L     // SIM not inserted
#define CME_SIM_PIN_REQUIRED               11L     // SIM PIN required
#define CME_SIM_PUK_REQUIRED               12L     // SIM PUK required
#define CME_SIM_FAILURE                    13L     // SIM failure
#define CME_IN_PROGRESS                   515L     // Operation in progress
#define CME_COMMAND_SYNTAX              34819L     // Bad Command: Syntax error
#define CME_COMMAND_TOO_LONG            34881L     // Bad Command: Command too long
#define CME_ALREADY_CONNECTED           35840L     // already connected
#define CME_NOT_REGISTERED              35865L     // Not registered on network
#define CME_INVALID_EVENT               35866L     // Invalid event during activation process
#define CME_PHYS_LAYER_CONN_INACTIVE    35867L     // Physical layer connection is currently not active
#define CME_GPRS_ABORTED                35868L     // Check APN
#define CME_SERVICE_RUNNING             37123L     // Service is running (can't set parm)
#define CME_SESSION_CLOSED_BY_PEER      37966L     // Session closed by peer
#define CME_DNS_ERROR                   38027L     // DNS lookup failed
#define CME_TCP_OPEN_ERROR              38016L     // TCP open failed
#define CME_GPRS_SESSION_FAILED         49155L     // Open GPRS session request failed

static const char *CME_ERROR_DESC(Int32 code)
{
    switch (code) {
        case CME_UNKNOWN                 : return "Unparsable error code";
        // "#CME ERROR:"
        case CME_COMMAND_SYNTAX          : return "Command syntax error";
        case CME_COMMAND_TOO_LONG        : return "Command too long";
        case CME_ALREADY_CONNECTED       : return "Already Connected";
        case CME_NOT_REGISTERED          : return "Not registered on network";
        case CME_INVALID_EVENT           : return "Invalid event during activation process";
        case CME_PHYS_LAYER_CONN_INACTIVE: return "Physical layer connection is currently not active";
        case CME_GPRS_ABORTED            : return "Check APN";
        case CME_SERVICE_RUNNING         : return "Service is running (can't set parameter)";
        case CME_DNS_ERROR               : return "DNS lookup failed";
        case CME_TCP_OPEN_ERROR          : return "TCP open failed";
        case CME_GPRS_SESSION_FAILED     : return "Open GPRS session request failed";
        // "+CME ERROR:"
        case CME_SIM_NOT_INSERTED        : return "SIM not inserted";
        case CME_SIM_PIN_REQUIRED        : return "SIM PIN required";
        case CME_SIM_PUK_REQUIRED        : return "SIM PUK required";
        case CME_SIM_FAILURE             : return "SIM Failure";
        case CME_IN_PROGRESS             : return "Operation in progress";
    }
    return "(Error Description Not Found)";
}

#define CME_ERROR_CHECK(RESP)   cmeErrorCheck_(__FILE__, __LINE__, RESP)
static utBool cmeErrorCheck_(const char *ftn, int line, const char *resp)
{
    Int32 cme = CME_ERROR(resp);
    if (cme > 0L) {
        if (cme > CME_UNKNOWN) {
            logWarning_(ftn, line, "[%ld] %s", (long)cme, CME_ERROR_DESC(cme));
        } else {
            logWarning_(ftn, line, "[?] %s", resp);
        }
        return utTrue;
    } else {
        return utFalse;
    }
}

#define ERROR_CHECK(RESP)   errorCheck_(__FILE__, __LINE__, RESP)
static utBool errorCheck_(const char *ftn, int line, const char *resp)
{
    if (strEqualsIgnoreCase(resp, RESULT_ERROR_VERBOSE)) {
        logWarning_(ftn, line, "%s", RESULT_ERROR_VERBOSE);
        return utTrue;
    } else
    if (strEqualsIgnoreCase(resp, RESULT_NOCARRIER_VERBOSE)) { 
        logWarning_(ftn, line, "%s", RESULT_NOCARRIER_VERBOSE);
        return utTrue;
    } else {
        return utFalse;
    }
}

// ----------------------------------------------------------------------------

/* control characters */
#define ASCII_ETX                   3
#define CONTROL_C                   ASCII_ETX
static char ETX_STRINGZ[] = { CONTROL_C, CONTROL_C, CONTROL_C, 0 };

// ----------------------------------------------------------------------------

// The Out-Of-Range timeout is checked first
// This probably shouldn't be less that a few hours, since this can occur under
// normal conditions when the modem is _really_ out of range of a GSM/GPRS towner.
#define MAX_OUTOFRANGE_TIMEOUT      MINUTE_SECONDS(180) // 3 hours

// Once the signal strength is finally valid, the 'Not Registered' timer is checked.
// This timeout can be relatively small.  This timeout would indicate that we've
// been receiving a satisfactory signal strength, but we've still not been able to
// register on the network.
#define MAX_UNREGISTERED_TIMEOUT    MINUTE_SECONDS(60) // 1 hour

// ----------------------------------------------------------------------------

static ComPort_t            blueComPort;

static utBool               blueTCPSocketOpen       = utFalse;

//static utBool               bluePowerOnReset        = utFalse;
static utBool               blueConnectionReset     = utTrue;
static utBool               blueStartupReset        = utTrue;

//static utBool               blueCOPS                = utFalse;

static TimerSec_t           blueLastComErrorTimer   = 0L;
static TimerSec_t           firstNotRegisteredTimer = 0L;
static TimerSec_t           firstOutOfRangeTimer    = 0L;

static UInt32               blueLastATZErrorCount   = 0L;

static char                 blueModemModel[80];
static char                 ipAddress[32];

// ----------------------------------------------------------------------------

void blueInitialize()
{
    comPortInitStruct(&blueComPort);

    /* set startup-reset flags */
    bluePowerOnReset        = utFalse;
    blueConnectionReset     = utTrue;
    blueStartupReset        = utTrue;
    blueLastComErrorTimer   = 0L;
    firstNotRegisteredTimer = 0L;
    firstOutOfRangeTimer    = 0L;
    blueLastATZErrorCount   = 0L;

}

// ----------------------------------------------------------------------------

void blueResetConnection()
{
    blueConnectionReset = utTrue;
}


// ----------------------------------------------------------------------------

#define BLUE_READLINE(C, RT, TMO, R, RLen) _blueReadLine(__FILE__, __LINE__, RT, TMO, R, RLen)

static utBool _blueReadLine(const char *ftn, int line, int retry, long timeoutMS, char *resp, int respLen)
{
    ComPort_t *com = &blueComPort;
    while (utTrue) {
        comPortFlushWhitespace(com, 100L);
        int len = comPortReadLine(com, resp, respLen, timeoutMS);
        if (len > 0) {
            // data was read
            break; 
        } else
        if (len < 0) {
            // ComPort error
            logWarning_(ftn, line, "Comport error");
            return utFalse; 
        } else {
            // timeout
            //logWarning_(ftn, line, "Comport timeout");
        }
        if (--retry <= 0) {
            // timeout
            logWarning_(ftn, line, "Comport read timeout");
            return utFalse; 
        }
    }
    return utTrue;
}

// ----------------------------------------------------------------------------

static utBool _blueSetDNS(const char *dns_1, const char *dns_2)
{
    ComPort_t *com = &blueComPort;
    char resp[128];
        
    /* DNS server #1 [ AT#DNSSERV1="0.0.0.0" ] */
    // Expect "OK" | "ERROR"
    if (dns_1 && *dns_1) {
        comPortWriteATFmt(com, "#DNSSERV1=\"%s\"", dns_1);
        while (utTrue) {
            if (!BLUE_READLINE(com, 1, 1000L, resp, sizeof(resp)))       { return utFalse; }
            if (strEqualsIgnoreCase(resp, RESULT_OK_VERBOSE))            { break; }
            if (ERROR_CHECK(resp) || CME_ERROR_CHECK(resp))              { 
                if (strEqualsIgnoreCase(resp, RESULT_SERIVCE_RUNNING)) {
                    // just closing the socket may be sufficient
                    blueConnectionReset = utTrue;
                }
                return utFalse; 
            }
        }
        comPortFlush(com, 100L);
    }
        
    /* DNS server #2 [ AT#DNSSERV2="0.0.0.0" ] */
    // Expect "OK" | "ERROR"
    if (dns_2 && *dns_2) {
        comPortWriteATFmt(com, "#DNSSERV2=\"%s\"", dns_2);
        while (utTrue) {
            if (!BLUE_READLINE(com, 1, 1000L, resp, sizeof(resp)))  { return utFalse; }
            if (strEqualsIgnoreCase(resp, RESULT_OK_VERBOSE))       { break; }
            if (ERROR_CHECK(resp) || CME_ERROR_CHECK(resp))         { 
                if (strEqualsIgnoreCase(resp, RESULT_SERIVCE_RUNNING)) {
                    // just closing the socket may be sufficient
                    blueConnectionReset = utTrue;
                }
                return utFalse; 
            }
        }
        comPortFlush(com, 100L);
    }
    
    return utTrue;
    
}

// ----------------------------------------------------------------------------

utBool blueOpenTCPSocket()
{
    ComPort_t *com = &blueComPort;
    char resp[600];
    const char *server = blueGetDataHost();
    int port = blueGetDataPort();
    logDEBUG(LOGSRC,"Openning TCP socket [%s:%d]", server, port);
    
    /* init open false */
    blueTCPSocketOpen = utFalse;
    
    /* set DNS */       
    const char *dns_1 = blueGetDNS(1);
    const char *dns_2 = blueGetDNS(2);
    if ((dns_1 && *dns_1) || (dns_2 && *dns_2)) {
        logDEBUG(LOGSRC,"Setting DNS: %s, %s", dns_1, dns_2);
        if (!_blueSetDNS(dns_1, dns_2)) { return utFalse; }
    }
    
    /* TCP server [ AT#TCPSERV="<host>" ] */
    // Expect "OK"
    comPortWriteATFmt(com, "#TCPSERV=\"%s\"", server);
    while (utTrue) {
        if (!BLUE_READLINE(com, 1, 1000L, resp, sizeof(resp)))  { return utFalse; }
        if (strEqualsIgnoreCase(resp, RESULT_OK_VERBOSE))       { break; }
        if (ERROR_CHECK(resp) || CME_ERROR_CHECK(resp))         { return utFalse; }
    }
    comPortFlush(com, 100L);
    
    /* TCP port [ AT#TCPPORT=<port> ] */
    // Expect "OK"
    comPortWriteATFmt(com, "#TCPPORT=%d", port);
    while (utTrue) {
        if (!BLUE_READLINE(com, 1, 1000L, resp, sizeof(resp)))  { return utFalse; }
        if (strEqualsIgnoreCase(resp, RESULT_OK_VERBOSE))       { break; }
        if (ERROR_CHECK(resp) || CME_ERROR_CHECK(resp))         { return utFalse; }
    }
    comPortFlush(com, 100L);
    
    /* open [ AT#OTCP ] */
    // Expect "Ok_Info_WaitingForData"
    comPortWriteAT(com, "#OTCP");
    while (utTrue) {
        // long timeout
        if (!BLUE_READLINE(com, 6, 20000L, resp, sizeof(resp))) { return utFalse; }
      //if (strEqualsIgnoreCase(resp, RESULT_OK_VERBOSE))       { return utFalse; } // <-- should not get this
        if (strEqualsIgnoreCase(resp, RESULT_TCP_ACTIVATION))   { break; } // success
        if (strEqualsIgnoreCase(resp, RESULT_SOCKET_CLOSED))    { return utFalse; }
        if (ERROR_CHECK(resp) || CME_ERROR_CHECK(resp))         {
            if (strEqualsIgnoreCase(resp, RESULT_INACTV_PHYS_LAYER))  {
                // TCP stack not initialized?
                // if we get here we need to close the current connection and start over.
                blueConnectionReset = utTrue;
            } else
            if (strEqualsIgnoreCase(resp, RESULT_DNS_LOOKUP_FAILED))  {
                // DNS failed to locate our server
                // if we get here we need to close the current connection and start over.
                blueConnectionReset = utTrue;
            }
            return utFalse;
        }
    }
    comPortFlush(com, 100L);