nc -l -p 9000

359*********549;

bool TrackerCoban::Identify( char *_buffer, int _nbytes, char *_pId )
{
    bool identified = false;

    if ( _nbytes > BUFF_LEN )
        _nbytes = BUFF_LEN;
    if ( _nbytes < 0 )
        _nbytes = 0;


    if ( (_nbytes >= 16) &&  isdigit(_buffer[0]) && isdigit(_buffer[14]) && (_buffer[15]==';') )
    {
        // <imei-number>;
        // heartbeat
        memcpy( _pId, _buffer, 15 );
        _pId[15] = '\0';
        identified = true;
    }
    else if ( (_nbytes >= 24) && (0 == strncmp( _buffer, "##,imei:", 8 )) &&  isdigit(_buffer[0+8]) && isdigit(_buffer[14+8]) && (_buffer[15+8]==',') )
    {
        // ##imei:<imei-number>
        // This is another Hearbeat, we shall answer with "LOAD"
        memcpy( _pId, _buffer+8, 15 );
        _pId[15] = '\0';
        identified = true;
    }
    else if ( (_nbytes >= 21) && (0 == strncmp( _buffer, "imei:", 5 )) &&  isdigit(_buffer[0+5]) && isdigit(_buffer[14+5]) && (_buffer[15+5]==',') )
    {
        // generic command
        // no fix : imei:359586015829802,tracker,000000000,13554900601,L,;
        // fix ok : imei:359587010124900,tracker,0809231929,13554900601,F,112909.397,A,2234.4669,N,11354.3287,E,0.11,;
        memcpy( _pId, _buffer+5, 15 );
        _pId[15] = '\0';
        identified = true;
    }

    return identified;
}

GtEvent::Type_e TrackerCoban::findType( char *_token )
{
    //     enum Type_e { Unknown=0, Heartbeat, Position, SOS, GeoFence, Move, Overspeed, LowBattery, Shutdown=999 };

    if ( 0 == strncmp( _token, "tracker", 7 ) )
        return GtEvent::Position;
    else if ( 0 == strncmp( _token, "help me", 7 ) )
        return GtEvent::SOS;
    else if ( 0 == strncmp( _token, "stockade", 8 ) )
        return GtEvent::GeoFence;
    else if ( 0 == strncmp( _token, "move", 4 ) )
        return GtEvent::Move;
    else if ( 0 == strncmp( _token, "speed", 5 ) )
        return GtEvent::Overspeed;
    else if ( 0 == strncmp( _token, "low battery", 11 ) )
        return GtEvent::LowBattery;
    else if ( 0 == strncmp( _token, "dt", 2 ) )
        return (GtEvent::Type_e)(-1);
    else if ( 0 == strncmp( _token, "et", 2 ) )
        return (GtEvent::Type_e)(-1);
    else if ( 0 == strncmp( _token, "gt", 2 ) )
        return (GtEvent::Type_e)(-1);
    else if ( 0 == strncmp( _token, "ht", 2 ) )
        return (GtEvent::Type_e)(-1);
    else if ( 0 == strncmp( _token, "it", 2 ) )
        return (GtEvent::Type_e)(-1);
    else if ( 0 == strncmp( _token, "nt", 2 ) )
        return (GtEvent::Type_e)(-1);
    else
        log( LOG_WARNING, "TkCoban%04u: Command not recognized : %s", pEndPoint->GetIdx(),(int)_token );

    return GtEvent::Unknown;
 }

GtEvent *TrackerCoban::Parse( unsigned char *_buffer, int _nbytes )
{
    if ( _nbytes > BUFF_LEN )
        _nbytes = BUFF_LEN;
    if ( _nbytes < 0 )
        _nbytes = 0;

    // filter spurious '\x0A'
    if ( (_nbytes > 0) && (*_buffer == '\x0A') )
    {
        ++_buffer;
        --_nbytes;
    }

    GtEvent *pEvent = GtSource::Parse( _buffer, _nbytes );

    DBG1( "Parse : '%s'", (int)wrkBuff );

    if ( _nbytes == 0 )
    {
        pEvent->type = GtEvent::Closing;
    }
    else if ( (_nbytes >= 15) && isdigit(wrkBuff[0]) && isdigit(wrkBuff[14]) && (wrkBuff[15]==';') )
    {
        // this is IMEI number, we shall answer with "ON"
        pEndPoint->Send( "ON", 2 );
        pEvent->type = GtEvent::Heartbeat;
    }
    else if ( (_nbytes >= 24) && (0 == strncmp( (char*)wrkBuff, "##,imei:", 8 )) && isdigit(wrkBuff[0+8]) && isdigit(wrkBuff[14+8]) && (wrkBuff[15+8]==',') )
    {
        // This is another Hearbeat, we shall answer with "LOAD"
        pEndPoint->Send( "LOAD", 4 );
        pEvent->type = GtEvent::Heartbeat;
    }
    else if ( (_nbytes >= 21) && (0 == strncmp( (char*)wrkBuff, "imei:", 5 )) && isdigit(wrkBuff[0+5]) && isdigit(wrkBuff[14+5]) && (wrkBuff[15+5]==',') )
    {
        // generic command
        // no fix : imei:359586015829802,tracker,000000000,13554900601,L,;
        // fix ok : imei:359587010124900,tracker,0809231929,13554900601,F,112909.397,A,2234.4669,N,11354.3287,E,0.11,;
        char *saveptr = NULL, *token;
        // imei value
        token = strTok_r( (char*)wrkBuff+5, ",", &saveptr );
        if ( !token ) return NULL;
        // command
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: command" );
            delete pEvent;
            return NULL;
        }
        pEvent->type = findType( token );
        DBG1( "Command : %d", pEvent->type );
        if ( pEvent->type <= 0 )
        {
            DBG2( "TkCoban: unknown or command acknoledgement %s '%s", (int)token, (int)_buffer );
            delete pEvent;
            return NULL;
        }
        // date
        char *pDate = strTok_r( NULL, ",", &saveptr );
        if ( !pDate )
        {
            DBG( "Parse error: date" );
            delete pEvent;
            return NULL;
        }
        if ( 10 != strlen(pDate) )
        {
            DBG( "Parse error: date (len!=10)" );
            delete pEvent;
            return NULL;
        }
        // unknown
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: 'unknown field'" );
            delete pEvent;
            return NULL;
        }
        // fix or no-fix
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: fix" );
            delete pEvent;
            return NULL;
        }
        if ( token[0] == 'L' )
        {
            if ( gotFix )
                log( LOG_WARNING, "TkCoban%04u: Fix lost!", pEndPoint->GetIdx() );
            gotFix = false;
            return pEvent;
        }
        if ( token[0] == 'F' )
        {
            if ( !gotFix )
                log( LOG_INFO, "TkCoban%04u: Got Fix!", pEndPoint->GetIdx() );
            gotFix = true;
        }
        else
        {
            DBG1( "Parse error: fix no-L, no-F : %s", (int)token );
            delete pEvent;
            return NULL;
        }
        // time
        char *pTime = strTok_r( NULL, ",", &saveptr );
        if ( !pTime )
        {
            DBG( "Parse error: time" );
            delete pEvent;
            return NULL;
        }
        if ( 10 != strlen(pTime) )
        {
            DBG( "Parse error: time (len!=10)" );
            delete pEvent;
            return NULL;
        }
        // A
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: 'A'" );
            delete pEvent;
            return NULL;
        }
        if ( token[0] != 'A' )
        {
            DBG1( "Parse error: 'A' not A : %s", (int)token );
            delete pEvent;
            return NULL;
        }
        // convert date/time
        struct tm tracktm;
        bzero( &tracktm, sizeof(tracktm) );
        tracktm.tm_sec  = atoi( pTime + 4 );
        pTime[4] = '\0';
        tracktm.tm_min  = atoi( pTime + 2 );
        pTime[2] = '\0';
        tracktm.tm_hour = atoi( pTime );
        pDate[6] = '\0';
        tracktm.tm_mday = atoi( pDate + 4 );
        pDate[4] = '\0';
        tracktm.tm_mon  = atoi( pDate + 2 ) - 1;
        pDate[2] = '\0';
        tracktm.tm_year = atoi( pDate ) + 100;
        //DBG3( "Date : %04d-%02d-%02d", tracktm.tm_year+1900, tracktm.tm_mon+1, tracktm.tm_mday );
        //DBG3( "Time : %02d:%02d:%02d", tracktm.tm_hour, tracktm.tm_min, tracktm.tm_sec );

        pEvent->point.time = timegm( &tracktm );
        //DBG1( "time_t : %d", pEvent->point.time );
        #if DEBUG
        struct tm *g_tm, *l_tm;
        g_tm = gmtime( &(pEvent->point.time) );
        DBG1( "gtime: %s", (int)asctime(g_tm));
        l_tm = localtime( &(pEvent->point.time) );
        DBG1( "ltime: %s", (int)asctime(l_tm));
        #endif
        // lat
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: Lat" );
            delete pEvent;
            return NULL;
        }
        double min = atof( token+2 );
        token[2] = '\0';
        double deg = atof( token );
        pEvent->point.lat = deg + min / 60.0;
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: Lat (N/S)" );
            delete pEvent;
            return NULL;
        }
        if ( token[0] == 'S' )
            pEvent->point.lat = - pEvent->point.lat;
        else if ( token[0] != 'N' )
        {
            DBG1( "Parse error: Lat, no-N, no-S : %s", (int)token );
            delete pEvent;
            return NULL;
        }
        // lon
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: Lon" );
            delete pEvent;
            return NULL;
        }
        min = atof( token+3 );
        token[3] = '\0';
        deg = atof( token );
        pEvent->point.lon = deg + min / 60.0;
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token )
        {
            DBG( "Parse error: Lon (E/W)" );
            delete pEvent;
            return NULL;
        }
        if ( token[0] == 'W' )
            pEvent->point.lon = - pEvent->point.lon;
        else if ( token[0] != 'E' )
        {
            DBG1( "Parse error: Lat, no-E, no-W : %s", (int)token );
            delete pEvent;
            return NULL;
        }
        // speed
        token = strTok_r( NULL, ",", &saveptr );
        if ( !token || !isdigit(token[0]) )
            pEvent->point.speed = GtPoint::INVALID;
        else
            pEvent->point.speed = atof( token ) * 1.852;
        pEvent->point.alt = GtPoint::INVALID;
        pEvent->point.isValid = true;

        DBG3( "Point %d, %d @ %d", (int)(1000.0*pEvent->point.lat), (int)(1000.0*pEvent->point.lon), (int)(1000.0*pEvent->point.speed)  );
    }

    if ( pEvent && (pEvent->type > GtEvent::Position) && (pEvent->point.isValid) )
    {
        SendCommand( "E", 1 );
    }

    return pEvent;
}

// function similar to standard strtok but which parse properly empty fields
// a,,c will return "a", "", "c" (while standard strtok would return "a", "c")
char *GtSource::strTok_r( char *_string, const char *_sep, char **psaveptr )
{

  char *retptr;
  char *savptr = *psaveptr;

  if ( _string )
    savptr = _string;

  retptr = savptr;
  while ( savptr && *savptr && !strchr( _sep, *savptr ) )
    ++savptr;

  if ( savptr && *savptr )
    *savptr++ = '\0';
  else
    savptr = NULL;

  *psaveptr = savptr;
  return retptr;
}