UbloxATCellularInterface.cpp

00001 /* Copyright (c) 2017 ublox Limited
00002  *
00003  * Licensed under the Apache License, Version 2.0 (the "License");
00004  * you may not use this file except in compliance with the License.
00005  * You may obtain a copy of the License at
00006  *
00007  *     http://www.apache.org/licenses/LICENSE-2.0
00008  *
00009  * Unless required by applicable law or agreed to in writing, software
00010  * distributed under the License is distributed on an "AS IS" BASIS,
00011  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00012  * See the License for the specific language governing permissions and
00013  * limitations under the License.
00014  */
00015 
00016 #include "UbloxATCellularInterface.h"
00017 #include "mbed_poll.h"
00018 #include "nsapi.h"
00019 #include "APN_db.h"
00020 #ifdef FEATURE_COMMON_PAL
00021 #include "mbed_trace.h"
00022 #define TRACE_GROUP "UACI"
00023 #else
00024 #define tr_debug(format, ...) debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__)
00025 #define tr_info(format, ...)  debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__)
00026 #define tr_warn(format, ...)  debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__)
00027 #define tr_error(format, ...) debug_if(_debug_trace_on, format "\n", ## __VA_ARGS__)
00028 #endif
00029 
00030 /**********************************************************************
00031  * PRIVATE METHODS
00032  **********************************************************************/
00033 
00034 // Event thread for asynchronous received data handling.
00035 void UbloxATCellularInterface::handle_event(){
00036     pollfh fhs;
00037     int at_timeout;
00038     fhs.fh = _fh;
00039     fhs.events = POLLIN;
00040 
00041     while (_run_event_thread) {
00042         int count;
00043         count = poll(&fhs, 1, 1000);
00044         if (count > 0 && (fhs.revents & POLLIN)) {
00045             LOCK();
00046             at_timeout = _at_timeout;
00047             at_set_timeout(10); // Avoid blocking but also make sure we don't
00048                                 // time out if we get ahead of the serial port
00049             _at->debug_on(false); // Debug here screws with the test output
00050             // Let the URCs run
00051             _at->recv(UNNATURAL_STRING);
00052             _at->debug_on(_debug_trace_on);
00053             at_set_timeout(at_timeout);
00054             UNLOCK();
00055         }
00056     }
00057 }
00058 
00059 // Find or create a socket from the list.
00060 UbloxATCellularInterface::SockCtrl * UbloxATCellularInterface::find_socket(int modem_handle)
00061 {
00062     UbloxATCellularInterface::SockCtrl *socket = NULL;
00063 
00064     for (unsigned int x = 0; (socket == NULL) && (x < sizeof(_sockets) / sizeof(_sockets[0])); x++) {
00065         if (_sockets[x].modem_handle == modem_handle) {
00066             socket = &(_sockets[x]);
00067         }
00068     }
00069 
00070     return socket;
00071 }
00072 
00073 // Clear out the storage for a socket
00074 void UbloxATCellularInterface::clear_socket(UbloxATCellularInterface::SockCtrl * socket)
00075 {
00076     if (socket != NULL) {
00077         socket->modem_handle = SOCKET_UNUSED;
00078         socket->pending     = 0;
00079         socket->callback    = NULL;
00080         socket->data        = NULL;
00081     }
00082 }
00083 
00084 // Check that a socket pointer is valid
00085 bool UbloxATCellularInterface::check_socket(SockCtrl * socket)
00086 {
00087     bool success = false;
00088 
00089     if (socket != NULL) {
00090         for (unsigned int x = 0; !success && (x < sizeof(_sockets) / sizeof(_sockets[0])); x++) {
00091             if (socket == &(_sockets[x])) {
00092                 success = true;
00093             }
00094         }
00095     }
00096 
00097     return success;
00098 }
00099 
00100 // Convert nsapi_security_t to the modem security numbers
00101 int UbloxATCellularInterface::nsapi_security_to_modem_security(nsapi_security_t nsapi_security)
00102 {
00103     int modem_security = 3;
00104 
00105     switch (nsapi_security)
00106     {
00107         case NSAPI_SECURITY_NONE:
00108             modem_security = 0;
00109             break;
00110         case NSAPI_SECURITY_PAP:
00111             modem_security = 1;
00112             break;
00113         case NSAPI_SECURITY_CHAP:
00114             modem_security = 2;
00115             break;
00116 #ifndef TARGET_UBLOX_C030_R41XM
00117         case NSAPI_SECURITY_UNKNOWN:
00118             modem_security = 3;
00119             break;
00120         default:
00121             modem_security = 3;
00122             break;
00123 #else
00124         default:
00125             modem_security = 0;
00126             break;
00127 #endif
00128     }
00129 
00130     return modem_security;
00131 }
00132 
00133 // Callback for Socket Read URC.
00134 void UbloxATCellularInterface::UUSORD_URC()
00135 {
00136     int a;
00137     int b;
00138     char buf[32];
00139     // Note: not calling _at->recv() from here as we're
00140     // already in an _at->recv()
00141     // +UUSORD: <socket>,<length>
00142     if (read_at_to_char(buf, sizeof (buf), '\n') > 0) {
00143 
00144         if (sscanf(buf, ": %d,%d", &a, &b) == 2) {
00145             SockCtrl *socket;
00146             socket = find_socket(a);
00147             if (socket != NULL) {
00148                 socket->pending = b;
00149                 // No debug prints here as they can affect timing
00150                 // and cause data loss in UARTSerial
00151                 if (socket->callback != NULL) {
00152                     socket->callback(socket->data);
00153                 }
00154             }
00155         }
00156     }
00157 }
00158 
00159 // Callback for Socket Read From URC.
00160 void UbloxATCellularInterface::UUSORF_URC()
00161 {
00162     int a;
00163     int b;
00164     char buf[32];
00165     // Note: not calling _at->recv() from here as we're
00166     // already in an _at->recv()
00167     // +UUSORF: <socket>,<length>
00168     if (read_at_to_char(buf, sizeof (buf), '\n') > 0) {
00169         if (sscanf(buf, ": %d,%d", &a, &b) == 2) {
00170             SockCtrl *socket;
00171             socket = find_socket(a);
00172             if (socket != NULL) {
00173                 socket->pending = b;
00174                 // No debug prints here as they can affect timing
00175                 // and cause data loss in UARTSerial
00176                 if (socket->callback != NULL) {
00177                     socket->callback(socket->data);
00178                 }
00179             }
00180         }
00181     }
00182 }
00183 
00184 // Callback for Socket Close URC.
00185 void UbloxATCellularInterface::UUSOCL_URC()
00186 {
00187     int a;
00188     char buf[32];
00189     // Note: not calling _at->recv() from here as we're
00190     // already in an _at->recv()
00191     // +UUSOCL: <socket>
00192     if (read_at_to_char(buf, sizeof (buf), '\n') > 0) {
00193         if (sscanf(buf, ": %d", &a) == 1) {
00194             SockCtrl *socket;
00195             socket = find_socket(a);
00196             tr_debug("Socket 0x%08x: handle %d closed by remote host",
00197                      (unsigned int) socket, a);
00198             clear_socket(socket);
00199         }
00200     }
00201 }
00202 
00203 // Callback for UUPSDD.
00204 void UbloxATCellularInterface::UUPSDD_URC()
00205 {
00206     int a;
00207     char buf[32];
00208     // Note: not calling _at->recv() from here as we're
00209     // already in an _at->recv()
00210     // +UUPSDD: <socket>
00211     if (read_at_to_char(buf, sizeof (buf), '\n') > 0) {
00212         if (sscanf(buf, ": %d", &a) == 1) {
00213             SockCtrl *socket;
00214             socket = find_socket(a);
00215             tr_debug("Socket 0x%08x: handle %d connection lost",
00216                      (unsigned int) socket, a);
00217             clear_socket(socket);
00218             if (_connection_status_cb) {
00219                 _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST);
00220             }
00221         }
00222     }
00223 }
00224 
00225 /**********************************************************************
00226  * PROTECTED METHODS: GENERAL
00227  **********************************************************************/
00228 
00229 // Get the next set of credentials, based on IMSI.
00230 void UbloxATCellularInterface::get_next_credentials(const char ** config)
00231 {
00232     if (*config) {
00233         _apn    = _APN_GET(*config);
00234         _uname  = _APN_GET(*config);
00235         _pwd    = _APN_GET(*config);
00236     }
00237 
00238     _apn    = _apn     ?  _apn    : "";
00239     _uname  = _uname   ?  _uname  : "";
00240     _pwd    = _pwd     ?  _pwd    : "";
00241 }
00242 
00243 // Active a connection profile on board the modem.
00244 // Note: the AT interface should be locked before this is called.
00245 bool UbloxATCellularInterface::activate_profile(const char* apn,
00246                                                 const char* username,
00247                                                 const char* password,
00248                                                 nsapi_security_t auth)
00249 {
00250     bool activated = false;
00251     bool success = false;
00252     int at_timeout = _at_timeout;
00253     SocketAddress address;
00254 
00255     // Set up the APN
00256     if (*apn) {
00257         success = _at->send("AT+UPSD=" PROFILE ",1,\"%s\"", apn) && _at->recv("OK");
00258     }
00259     if (success && *username) {
00260         success = _at->send("AT+UPSD=" PROFILE ",2,\"%s\"", username) && _at->recv("OK");
00261     }
00262     if (success && *password) {
00263         success = _at->send("AT+UPSD=" PROFILE ",3,\"%s\"", password) && _at->recv("OK");
00264     }
00265 
00266     if (success) {
00267         // Set up dynamic IP address assignment.
00268         success = _at->send("AT+UPSD=" PROFILE ",7,\"0.0.0.0\"") && _at->recv("OK");
00269         // Set up the authentication protocol
00270         // 0 = none
00271         // 1 = PAP (Password Authentication Protocol)
00272         // 2 = CHAP (Challenge Handshake Authentication Protocol)
00273         for (int protocol = nsapi_security_to_modem_security(NSAPI_SECURITY_NONE);
00274              success && (protocol <= nsapi_security_to_modem_security(NSAPI_SECURITY_CHAP)); protocol++) {
00275             if ((_auth == NSAPI_SECURITY_UNKNOWN) || (nsapi_security_to_modem_security(_auth) == protocol)) {
00276                 if (_at->send("AT+UPSD=" PROFILE ",6,%d", protocol) && _at->recv("OK")) {
00277                     // Activate, waiting 30 seconds for the connection to be made
00278                     at_set_timeout(30000);
00279                     activated = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK");
00280                     at_set_timeout(at_timeout);
00281                 }
00282             }
00283         }
00284     }
00285 
00286     return activated;
00287 }
00288 
00289 // Activate a profile by reusing an external PDP context.
00290 // Note: the AT interface should be locked before this is called.
00291 bool UbloxATCellularInterface::activate_profile_reuse_external(void)
00292 {
00293     bool success = false;
00294     int cid = -1;
00295     SocketAddress address;
00296     int t;
00297     int at_timeout = _at_timeout;
00298 
00299     //+CGDCONT: <cid>,"IP","<apn name>","<ip adr>",0,0,0,0,0,0
00300     if (_at->send("AT+CGDCONT?")) {
00301         char ip[NSAPI_IP_SIZE];
00302         if (_at->recv("+CGDCONT: %d,\"IP\",\"%*[^\"]\",\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\",%*d,%*d,%*d,%*d,%*d,%*d",
00303                       &t, ip) &&
00304             _at->recv("OK")) {
00305             // Check if the IP address is valid
00306             if (address.set_ip_address(ip)) {
00307                 cid = t;
00308             }
00309         }
00310     }
00311 
00312     // If a context has been found, use it
00313     if ((cid != -1) && (_at->send("AT+UPSD=" PROFILE ",100,%d", cid) && _at->recv("OK"))) {
00314         // Activate, waiting 30 seconds for the connection to be made
00315         at_set_timeout(30000);
00316         success = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK");
00317         at_set_timeout(at_timeout);
00318     }
00319 
00320     return success;
00321 }
00322 
00323 // Activate a profile by context ID.
00324 // Note: the AT interface should be locked before this is called.
00325 bool UbloxATCellularInterface::activate_profile_by_cid(int cid,
00326                                                        const char* apn,
00327                                                        const char* username,
00328                                                        const char* password,
00329                                                        nsapi_security_t auth)
00330 {
00331     bool success = false;
00332     int at_timeout = _at_timeout;
00333 
00334 #ifndef TARGET_UBLOX_C030_R41XM
00335     if (_at->send("AT+CGDCONT=%d,\"IP\",\"%s\"", cid, apn) && _at->recv("OK") &&
00336         _at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, nsapi_security_to_modem_security(auth),
00337                   username, password) && _at->recv("OK") &&
00338         _at->send("AT+UPSD=" PROFILE ",100,%d", cid) && _at->recv("OK")) {
00339 
00340         // Wait 30 seconds for the connection to be made
00341         at_set_timeout(30000);
00342         // Activate the protocol
00343         success = _at->send("AT+UPSDA=" PROFILE ",3") && _at->recv("OK");
00344         at_set_timeout(at_timeout);
00345     }
00346 #else
00347     int modem_security = nsapi_security_to_modem_security(auth);
00348     if (_at->send("AT+CGDCONT=%d,\"IP\",\"%s\"", cid, apn) && _at->recv("OK")) {
00349         if ( modem_security == NSAPI_SECURITY_CHAP) {
00350             if (_at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, modem_security,
00351                         password, username) && _at->recv("OK")) {
00352                 success = true;
00353             }
00354         } else if (modem_security == NSAPI_SECURITY_NONE) {
00355             if (_at->send("AT+UAUTHREQ=%d,%d", cid, modem_security) && _at->recv("OK")) {
00356                 success = true;
00357             }
00358         } else {
00359             if (_at->send("AT+UAUTHREQ=%d,%d,\"%s\",\"%s\"", cid, modem_security,
00360                           username, password) && _at->recv("OK")) {
00361                 success = true;
00362             }
00363         }
00364     }
00365 #endif
00366 
00367     return success;
00368 }
00369 
00370 #ifdef TARGET_UBLOX_C030_R41XM
00371 //define PDP context for R412M
00372 bool UbloxATCellularInterface::define_context()
00373 {
00374     bool success = false;
00375     const char * config = NULL;
00376     LOCK();
00377 
00378     // If the caller hasn't entered an APN, try to find it
00379     if (_apn == NULL) {
00380         config = apnconfig(_dev_info.imsi);
00381     }
00382 
00383     // Attempt to connect
00384     do {
00385         // Set up APN and IP protocol for PDP context
00386         get_next_credentials(&config);
00387         _auth = (*_uname && *_pwd) ? _auth : NSAPI_SECURITY_NONE;
00388         if (activate_profile_by_cid(1, _apn, _uname, _pwd, _auth)) {
00389             success = true;
00390         }
00391     } while (!success && config && *config);
00392 
00393     if (!success) {
00394         tr_error("Failed to connect, check your APN/username/password");
00395     }
00396 
00397     UNLOCK();
00398     return success;
00399 }
00400 bool UbloxATCellularInterface::activate_context()
00401 {
00402     bool status = false;
00403     int at_timeout;
00404     LOCK();
00405 
00406     at_timeout = _at_timeout; // Has to be inside LOCK()s
00407     at_set_timeout(150000);
00408     if (_at->send("AT+CGACT=1,1") && _at->recv("OK")) {
00409         status = true;
00410     }
00411 
00412     at_set_timeout(at_timeout);
00413 
00414     UNLOCK();
00415     return status;
00416 }
00417 #endif
00418 
00419 // Connect the on board IP stack of the modem.
00420 bool UbloxATCellularInterface::connect_modem_stack()
00421 {
00422     bool success = false;
00423     int active = 0;
00424     const char * config = NULL;
00425     LOCK();
00426 
00427     // Check the profile
00428     if (_at->send("AT+UPSND=" PROFILE ",8") && _at->recv("+UPSND: %*d,%*d,%d\n", &active) &&
00429         _at->recv("OK")) {
00430         if (active == 0) {
00431             // If the caller hasn't entered an APN, try to find it
00432             if (_apn == NULL) {
00433                 config = apnconfig(_dev_info.imsi);
00434             }
00435 
00436             // Attempt to connect
00437             do {
00438                 // Set up APN and IP protocol for PDP context
00439                 get_next_credentials(&config);
00440                 _auth = (*_uname && *_pwd) ? _auth : NSAPI_SECURITY_NONE;
00441                 if ((_dev_info.dev != DEV_TOBY_L2) && (_dev_info.dev != DEV_MPCI_L2)) {
00442                     success = activate_profile(_apn, _uname, _pwd, _auth);
00443                 } else {
00444                     success = activate_profile_reuse_external();
00445                     if (success) {
00446                         tr_debug("Reusing external context");
00447                     } else {
00448                         success = activate_profile_by_cid(1, _apn, _uname, _pwd, _auth);
00449                     }
00450                 }
00451             } while (!success && config && *config);
00452         } else {
00453             // If the profile is already active, we're good
00454             success = true;
00455         }
00456     }
00457 
00458     if (!success) {
00459         tr_error("Failed to connect, check your APN/username/password");
00460     }
00461 
00462     UNLOCK();
00463     return success;
00464 }
00465 
00466 // Disconnect the on board IP stack of the modem.
00467 bool UbloxATCellularInterface::disconnect_modem_stack()
00468 {
00469     bool success = false;
00470     int active;
00471     Timer t1;
00472     LOCK();
00473 
00474     if (get_ip_address() != NULL) {
00475         if (_at->send("AT+UPSDA=" PROFILE ",4") && _at->recv("OK")) {
00476             success = true;
00477             if (_connection_status_cb) {
00478                 _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST);
00479             }
00480         }
00481     }
00482     t1.start();
00483     while (!(t1.read() >= 180)) {
00484         if (_at->send("AT+UPSND=" PROFILE ",8") && _at->recv("+UPSND: %*d,%*d,%d\n", &active) && _at->recv("OK")) {
00485 
00486             if (active == 0) {  //If context is deactivated, exit while loop and return status
00487                 tr_debug("Profile deactivated successfully");
00488                 break;
00489             }
00490             else {
00491                 tr_error("Profile still active");
00492                 rtos::ThisThread::sleep_for(5000); //Wait for 5 seconds and then try again
00493             }
00494         }
00495     }
00496     t1.stop();
00497 
00498     UNLOCK();
00499     return success;
00500 }
00501 
00502 /**********************************************************************
00503  * PROTECTED METHODS: NETWORK INTERFACE and SOCKETS
00504  **********************************************************************/
00505 
00506 // Gain access to us.
00507 NetworkStack *UbloxATCellularInterface::get_stack()
00508 {
00509     return this;
00510 }
00511 
00512 // Create a socket.
00513 nsapi_error_t UbloxATCellularInterface::socket_open(nsapi_socket_t *handle,
00514                                                     nsapi_protocol_t proto)
00515 {
00516     nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
00517     int modem_handle;
00518     SockCtrl *socket;
00519     LOCK();
00520 
00521     // Find a free socket
00522     socket = find_socket();
00523     tr_debug("socket_open(%d)", proto);
00524 
00525     if (socket != NULL) {
00526         bool success = false;
00527         if (proto == NSAPI_UDP) {
00528             success = _at->send("AT+USOCR=17");
00529         } else if (proto == NSAPI_TCP) {
00530             success = _at->send("AT+USOCR=6");
00531         } else  {
00532             nsapi_error = NSAPI_ERROR_UNSUPPORTED;
00533         }
00534 
00535         if (success) {
00536             nsapi_error = NSAPI_ERROR_NO_SOCKET;
00537             if (_at->recv("+USOCR: %d\n", &modem_handle) && (modem_handle != SOCKET_UNUSED) &&
00538                 _at->recv("OK")) {
00539                 tr_debug("Socket 0x%8x: handle %d was created", (unsigned int) socket, modem_handle);
00540                 clear_socket(socket);
00541                 socket->modem_handle         = modem_handle;
00542                 *handle = (nsapi_socket_t) socket;
00543                 nsapi_error = NSAPI_ERROR_OK;
00544             }
00545         }
00546     } else {
00547         nsapi_error = NSAPI_ERROR_NO_MEMORY;
00548     }
00549 
00550     UNLOCK();
00551     return nsapi_error;
00552 }
00553 
00554 // Close a socket.
00555 nsapi_error_t UbloxATCellularInterface::socket_close(nsapi_socket_t handle)
00556 {
00557     nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
00558     SockCtrl *socket = (SockCtrl *) handle;
00559     LOCK();
00560 
00561     tr_debug("socket_close(0x%08x)", (unsigned int) handle);
00562 
00563     MBED_ASSERT (check_socket(socket));
00564 
00565     if (_at->send("AT+USOCL=%d", socket->modem_handle) &&
00566         _at->recv("OK")) {
00567         clear_socket(socket);
00568         nsapi_error = NSAPI_ERROR_OK;
00569     }
00570 
00571     UNLOCK();
00572     return nsapi_error;
00573 }
00574 
00575 // Bind a local port to a socket.
00576 nsapi_error_t UbloxATCellularInterface::socket_bind(nsapi_socket_t handle,
00577                                                     const SocketAddress &address)
00578 {
00579     nsapi_error_t nsapi_error = NSAPI_ERROR_NO_SOCKET;
00580     int proto;
00581     int modem_handle;
00582     SockCtrl savedSocket;
00583     SockCtrl *socket = (SockCtrl *) handle;
00584     LOCK();
00585 
00586     tr_debug("socket_bind(0x%08x, :%d)", (unsigned int) handle, address.get_port());
00587 
00588     MBED_ASSERT (check_socket(socket));
00589 
00590     // Query the socket type
00591     if (_at->send("AT+USOCTL=%d,0", socket->modem_handle) &&
00592         _at->recv("+USOCTL: %*d,0,%d\n", &proto) &&
00593         _at->recv("OK")) {
00594         savedSocket = *socket;
00595         nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
00596         // Now close the socket and re-open it with the binding given
00597         if (_at->send("AT+USOCL=%d", socket->modem_handle) &&
00598             _at->recv("OK")) {
00599             clear_socket(socket);
00600             nsapi_error = NSAPI_ERROR_CONNECTION_LOST;
00601             if (_at->send("AT+USOCR=%d,%d", proto, address.get_port()) &&
00602                 _at->recv("+USOCR: %d\n", &modem_handle) && (modem_handle != SOCKET_UNUSED) &&
00603                 _at->recv("OK")) {
00604                 *socket = savedSocket;
00605                 nsapi_error = NSAPI_ERROR_OK;
00606             }
00607         }
00608     }
00609 
00610     UNLOCK();
00611     return nsapi_error;
00612 }
00613 
00614 // Connect to a socket
00615 nsapi_error_t UbloxATCellularInterface::socket_connect(nsapi_socket_t handle,
00616                                                        const SocketAddress &address)
00617 {
00618     nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
00619     SockCtrl *socket = (SockCtrl *) handle;
00620     LOCK();
00621 
00622     tr_debug("socket_connect(0x%08x, %s(:%d))", (unsigned int) handle,
00623              address.get_ip_address(), address.get_port());
00624 
00625     MBED_ASSERT (check_socket(socket));
00626 
00627     if (_at->send("AT+USOCO=%d,\"%s\",%d", socket->modem_handle,
00628                   address.get_ip_address(), address.get_port()) &&
00629         _at->recv("OK")) {
00630         nsapi_error = NSAPI_ERROR_OK;
00631     }
00632 
00633     UNLOCK();
00634     return nsapi_error;
00635 }
00636 
00637 // Send to a socket.
00638 nsapi_size_or_error_t UbloxATCellularInterface::socket_send(nsapi_socket_t handle,
00639                                                             const void *data,
00640                                                             nsapi_size_t size)
00641 {
00642     nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR;
00643     bool success = true;
00644     const char *buf = (const char *) data;
00645     nsapi_size_t blk = MAX_WRITE_SIZE;
00646     nsapi_size_t count = size;
00647     SockCtrl *socket = (SockCtrl *) handle;
00648 
00649     tr_debug("socket_send(0x%08x, 0x%08x, %d)", (unsigned int) handle, (unsigned int) data, size);
00650 
00651     MBED_ASSERT (check_socket(socket));
00652 
00653     if (socket->modem_handle == SOCKET_UNUSED) {
00654         tr_debug("socket_send: socket closed");
00655         return NSAPI_ERROR_NO_SOCKET;
00656     }
00657 
00658     while ((count > 0) && success) {
00659         if (count < blk) {
00660             blk = count;
00661         }
00662         LOCK();
00663 
00664         if (_at->send("AT+USOWR=%d,%d", socket->modem_handle, blk) && _at->recv("@")) {
00665             wait_ms(50);
00666             if ((_at->write(buf, blk) < (int) blk) ||
00667                  !_at->recv("OK")) {
00668                 success = false;
00669             }
00670         } else {
00671             success = false;
00672         }
00673 
00674         UNLOCK();
00675         buf += blk;
00676         count -= blk;
00677     }
00678 
00679     if (success) {
00680         nsapi_error_size = size - count;
00681         if (_debug_trace_on) {
00682             tr_debug("socket_send: %d \"%*.*s\"", size, size, size, (char *) data);
00683         }
00684     }
00685 
00686     return nsapi_error_size;
00687 }
00688 
00689 // Send to an IP address.
00690 nsapi_size_or_error_t UbloxATCellularInterface::socket_sendto(nsapi_socket_t handle,
00691                                                               const SocketAddress &address,
00692                                                               const void *data,
00693                                                               nsapi_size_t size)
00694 {
00695     nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR;
00696     bool success = true;
00697     const char *buf = (const char *) data;
00698     nsapi_size_t blk = MAX_WRITE_SIZE;
00699     nsapi_size_t count = size;
00700     SockCtrl *socket = (SockCtrl *) handle;
00701 
00702     tr_debug("socket_sendto(0x%8x, %s(:%d), 0x%08x, %d)", (unsigned int) handle,
00703              address.get_ip_address(), address.get_port(), (unsigned int) data, size);
00704 
00705     MBED_ASSERT (check_socket(socket));
00706 
00707     if (size > MAX_WRITE_SIZE) {
00708         tr_warn("WARNING: packet length %d is too big for one UDP packet (max %d), will be fragmented.", size, MAX_WRITE_SIZE);
00709     }
00710 
00711     while ((count > 0) && success) {
00712         if (count < blk) {
00713             blk = count;
00714         }
00715         LOCK();
00716 
00717         if (_at->send("AT+USOST=%d,\"%s\",%d,%d", socket->modem_handle,
00718                       address.get_ip_address(), address.get_port(), blk) &&
00719             _at->recv("@")) {
00720             wait_ms(50);
00721             if ((_at->write(buf, blk) >= (int) blk) &&
00722                  _at->recv("OK")) {
00723             } else {
00724                 success = false;
00725             }
00726         } else {
00727             success = false;
00728         }
00729 
00730         UNLOCK();
00731         buf += blk;
00732         count -= blk;
00733     }
00734 
00735     if (success) {
00736         nsapi_error_size = size - count;
00737         if (_debug_trace_on) {
00738             tr_debug("socket_sendto: %d \"%*.*s\"", size, size, size, (char *) data);
00739         }
00740     }
00741 
00742     return nsapi_error_size;
00743 }
00744 
00745 // Receive from a socket, TCP style.
00746 nsapi_size_or_error_t UbloxATCellularInterface::socket_recv(nsapi_socket_t handle,
00747                                                             void *data,
00748                                                             nsapi_size_t size)
00749 {
00750     nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR;
00751     bool success = true;
00752     char *buf = (char *) data;
00753     nsapi_size_t read_blk;
00754     nsapi_size_t count = 0;
00755     unsigned int usord_sz;
00756     int read_sz;
00757     Timer timer;
00758     SockCtrl *socket = (SockCtrl *) handle;
00759 
00760 
00761     tr_debug("socket_recv(0x%08x, 0x%08x, %d)",
00762              (unsigned int) handle, (unsigned int) data, size);
00763 
00764     MBED_ASSERT (check_socket(socket));
00765 
00766     if (socket->modem_handle == SOCKET_UNUSED) {
00767         tr_debug("socket_recv: socket closed");
00768         return NSAPI_ERROR_NO_SOCKET;
00769     }
00770 
00771     timer.start();
00772 
00773     while (success && (size > 0)) {
00774         int at_timeout;
00775         LOCK();
00776         at_timeout = _at_timeout;
00777         at_set_timeout(1000);
00778 
00779         read_blk = MAX_READ_SIZE;
00780         if (read_blk > size) {
00781             read_blk = size;
00782         }
00783         if (socket->pending > 0) {
00784             tr_debug("Socket 0x%08x: modem handle %d has %d byte(s) pending",
00785                      (unsigned int) socket, socket->modem_handle, socket->pending);
00786             _at->debug_on(false); // ABSOLUTELY no time for debug here if you want to
00787                                   // be able to read packets of any size without
00788                                   // losing characters in UARTSerial
00789             if (_at->send("AT+USORD=%d,%d", socket->modem_handle, read_blk) &&
00790                 _at->recv("+USORD: %*d,%d,\"", &usord_sz)) {
00791                 // Must use what +USORD returns here as it may be less or more than we asked for
00792                 if (usord_sz > socket->pending) {
00793                     socket->pending = 0;
00794                 } else {
00795                     socket->pending -= usord_sz; 
00796                 }
00797                 // Note: insert no debug between _at->recv() and _at->read(), no time...
00798                 if (usord_sz > size) {
00799                     usord_sz = size;
00800                 }
00801                 read_sz = _at->read(buf, usord_sz);
00802                 if (read_sz > 0) {
00803                     tr_debug("...read %d byte(s) from modem handle %d...", read_sz,
00804                              socket->modem_handle);
00805                     if (_debug_trace_on) {
00806                         tr_debug("Read returned %d,  |%*.*s|", read_sz, read_sz, read_sz, buf);
00807                     }
00808                     count += read_sz;
00809                     buf += read_sz;
00810                     size -= read_sz;
00811                 } else {
00812                     // read() should not fail
00813                     success = false;
00814                 }
00815                 tr_debug("Socket 0x%08x: modem handle %d now has only %d byte(s) pending",
00816                          (unsigned int) socket, socket->modem_handle, socket->pending);
00817                 // Wait for the "OK" before continuing
00818                 _at->recv("OK");
00819             } else {
00820                 // Should never fail to do _at->send()/_at->recv()
00821                 success = false;
00822             }
00823             _at->debug_on(_debug_trace_on);
00824         } else if (timer.read_ms() < SOCKET_TIMEOUT) {
00825             // Wait for URCs
00826             _at->recv(UNNATURAL_STRING);
00827         } else {
00828             if (count == 0) {
00829                 // Timeout with nothing received
00830                 nsapi_error_size = NSAPI_ERROR_WOULD_BLOCK;
00831                 success = false;
00832             }
00833             size = 0; // This simply to cause an exit
00834         }
00835 
00836         at_set_timeout(at_timeout);
00837         UNLOCK();
00838     }
00839     timer.stop();
00840 
00841     if (success) {
00842         nsapi_error_size = count;
00843     }
00844 
00845     if (_debug_trace_on) {
00846         tr_debug("socket_recv: %d \"%*.*s\"", count, count, count, buf - count);
00847     } else {
00848         tr_debug("socket_recv: received %d byte(s)", count);
00849     }
00850 
00851     return nsapi_error_size;
00852 }
00853 
00854 // Receive a packet over a UDP socket.
00855 nsapi_size_or_error_t UbloxATCellularInterface::socket_recvfrom(nsapi_socket_t handle,
00856                                                                 SocketAddress *address,
00857                                                                 void *data,
00858                                                                 nsapi_size_t size)
00859 {
00860     nsapi_size_or_error_t nsapi_error_size = NSAPI_ERROR_DEVICE_ERROR;
00861     bool success = true;
00862     char *buf = (char *) data;
00863     nsapi_size_t read_blk;
00864     nsapi_size_t count = 0;
00865     char ipAddress[NSAPI_IP_SIZE];
00866     int port;
00867     unsigned int usorf_sz;
00868     int read_sz;
00869     Timer timer;
00870     SockCtrl *socket = (SockCtrl *) handle;
00871 
00872     tr_debug("socket_recvfrom(0x%08x, 0x%08x, %d)",
00873              (unsigned int) handle, (unsigned int) data, size);
00874 
00875     MBED_ASSERT (check_socket(socket));
00876 
00877     timer.start();
00878 
00879     while (success && (size > 0)) {
00880         int at_timeout;
00881         LOCK();
00882         at_timeout = _at_timeout;
00883         at_set_timeout(1000);
00884 
00885         read_blk = MAX_READ_SIZE;
00886         if (read_blk > size) {
00887             read_blk = size;
00888         }
00889         if (socket->pending > 0) {
00890             tr_debug("Socket 0x%08x: modem handle %d has %d byte(s) pending",
00891                      (unsigned int) socket, socket->modem_handle, socket->pending);
00892             memset (ipAddress, 0, sizeof (ipAddress)); // Ensure terminator
00893 
00894             // Note: the maximum length of UDP packet we can receive comes from
00895             // fitting all of the following into one buffer:
00896             //
00897             // +USORF: xx,"max.len.ip.address.ipv4.or.ipv6",yyyyy,wwww,"the_data"\r\n
00898             //
00899             // where xx is the handle, max.len.ip.address.ipv4.or.ipv6 is NSAPI_IP_SIZE,
00900             // yyyyy is the port number (max 65536), wwww is the length of the data and
00901             // the_data is binary data. I make that 29 + 48 + len(the_data),
00902             // so the overhead is 77 bytes.
00903 
00904             _at->debug_on(false); // ABSOLUTELY no time for debug here if you want to
00905                                   // be able to read packets of any size without
00906                                   // losing characters in UARTSerial
00907             if (_at->send("AT+USORF=%d,%d", socket->modem_handle, read_blk) &&
00908                 _at->recv("+USORF: %*d,\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\",%d,%d,\"",
00909                           ipAddress, &port, &usorf_sz)) {
00910                 // Must use what +USORF returns here as it may be less or more than we asked for
00911                 if (usorf_sz > socket->pending) {
00912                     socket->pending = 0;
00913                 } else {
00914                     socket->pending -= usorf_sz; 
00915                 }
00916                 // Note: insert no debug between _at->recv() and _at->read(), no time...
00917                 if (usorf_sz > size) {
00918                     usorf_sz = size;
00919                 }
00920                 read_sz = _at->read(buf, usorf_sz);
00921                 if (read_sz > 0) {
00922                     address->set_ip_address(ipAddress);
00923                     address->set_port(port);
00924                     tr_debug("...read %d byte(s) from modem handle %d...", read_sz,
00925                              socket->modem_handle);
00926                     if (_debug_trace_on) {
00927                         tr_debug("Read returned %d,  |%*.*s|", read_sz, read_sz, read_sz, buf);
00928                     }
00929                     count += read_sz;
00930                     buf += read_sz;
00931                     size -= read_sz;
00932                     if ((usorf_sz < read_blk) || (usorf_sz == MAX_READ_SIZE)) {
00933                         size = 0; // If we've received less than we asked for, or
00934                                   // the max size, then a whole UDP packet has arrived and
00935                                   // this means DONE.
00936                     }
00937                 } else {
00938                     // read() should not fail
00939                     success = false;
00940                 }
00941                 tr_debug("Socket 0x%08x: modem handle %d now has only %d byte(s) pending",
00942                          (unsigned int) socket, socket->modem_handle, socket->pending);
00943                 // Wait for the "OK" before continuing
00944                 _at->recv("OK");
00945             } else {
00946                 // Should never fail to do _at->send()/_at->recv()
00947                 success = false;
00948             }
00949             _at->debug_on(_debug_trace_on);
00950         } else if (timer.read_ms() < SOCKET_TIMEOUT) {
00951             // Wait for URCs
00952             _at->recv(UNNATURAL_STRING);
00953         } else {
00954             if (count == 0) {
00955                 // Timeout with nothing received
00956                 nsapi_error_size = NSAPI_ERROR_WOULD_BLOCK;
00957                 success = false;
00958             }
00959             size = 0; // This simply to cause an exit
00960         }
00961 
00962         at_set_timeout(at_timeout);
00963         UNLOCK();
00964     }
00965     timer.stop();
00966 
00967     if (success) {
00968         nsapi_error_size = count;
00969     }
00970 
00971     if (_debug_trace_on) {
00972         tr_debug("socket_recvfrom: %d \"%*.*s\"", count, count, count, buf - count);
00973     } else {
00974         tr_debug("socket_recvfrom: received %d byte(s)", count);
00975     }
00976 
00977     return nsapi_error_size;
00978 }
00979 
00980 // Attach an event callback to a socket, required for asynchronous
00981 // data reception
00982 void UbloxATCellularInterface::socket_attach(nsapi_socket_t handle,
00983                                              void (*callback)(void *),
00984                                              void *data)
00985 {
00986     SockCtrl *socket = (SockCtrl *) handle;
00987 
00988     MBED_ASSERT (check_socket(socket));
00989 
00990     socket->callback = callback;
00991     socket->data = data;
00992 }
00993 
00994 // Unsupported TCP server functions.
00995 nsapi_error_t UbloxATCellularInterface::socket_listen(nsapi_socket_t handle,
00996                                                       int backlog)
00997 {
00998     return NSAPI_ERROR_UNSUPPORTED;
00999 }
01000 nsapi_error_t UbloxATCellularInterface::socket_accept(nsapi_socket_t server,
01001                                                       nsapi_socket_t *handle,
01002                                                       SocketAddress *address)
01003 {
01004     return NSAPI_ERROR_UNSUPPORTED;
01005 }
01006 
01007 // Unsupported option functions.
01008 nsapi_error_t UbloxATCellularInterface::setsockopt(nsapi_socket_t handle,
01009                                                    int level, int optname,
01010                                                    const void *optval,
01011                                                    unsigned optlen)
01012 {
01013     return NSAPI_ERROR_UNSUPPORTED;
01014 }
01015 nsapi_error_t UbloxATCellularInterface::getsockopt(nsapi_socket_t handle,
01016                                                    int level, int optname,
01017                                                    void *optval,
01018                                                    unsigned *optlen)
01019 {
01020     return NSAPI_ERROR_UNSUPPORTED;
01021 }
01022 
01023 /**********************************************************************
01024  * PUBLIC METHODS
01025  **********************************************************************/
01026 
01027 // Constructor.
01028 UbloxATCellularInterface::UbloxATCellularInterface(PinName tx,
01029                                                    PinName rx,
01030                                                    int baud,
01031                                                    bool debug_on,
01032                                                    osPriority priority)
01033 {
01034     _sim_pin_check_change_pending = false;
01035     _sim_pin_check_change_pending_enabled_value = false;
01036     _sim_pin_change_pending = false;
01037     _sim_pin_change_pending_new_pin_value = NULL;
01038     _run_event_thread = true;
01039     _apn = NULL;
01040     _uname = NULL;
01041     _pwd = NULL;
01042 
01043 
01044 
01045 
01046     // Initialise sockets storage
01047     memset(_sockets, 0, sizeof(_sockets));
01048     for (unsigned int socket = 0; socket < sizeof(_sockets) / sizeof(_sockets[0]); socket++) {
01049         _sockets[socket].modem_handle = SOCKET_UNUSED;
01050         _sockets[socket].callback = NULL;
01051         _sockets[socket].data = NULL;
01052     }
01053 
01054     // The authentication to use
01055     _auth = NSAPI_SECURITY_UNKNOWN;
01056 
01057     // Nullify the temporary IP address storage
01058     _ip = NULL;
01059     _connection_status_cb = NULL;
01060 
01061 
01062     // Initialise the base class, which starts the AT parser
01063     baseClassInit(tx, rx, baud, debug_on);
01064 
01065     // Start the event handler thread for Rx data
01066     event_thread.start(callback(this, &UbloxATCellularInterface::handle_event));
01067     event_thread.set_priority(priority);
01068 
01069     // URC handlers for sockets
01070     _at->oob("+UUSORD", callback(this, &UbloxATCellularInterface::UUSORD_URC));
01071     _at->oob("+UUSORF", callback(this, &UbloxATCellularInterface::UUSORF_URC));
01072     _at->oob("+UUSOCL", callback(this, &UbloxATCellularInterface::UUSOCL_URC));
01073     _at->oob("+UUPSDD", callback(this, &UbloxATCellularInterface::UUPSDD_URC));
01074 }
01075 
01076 // Destructor.
01077 UbloxATCellularInterface::~UbloxATCellularInterface()
01078 {
01079     // Let the event thread shut down tidily
01080     _run_event_thread = false;
01081     event_thread.join();
01082     
01083     // Free _ip if it was ever allocated
01084     free(_ip);
01085 }
01086 
01087 // Set the authentication scheme.
01088 void UbloxATCellularInterface::set_authentication(nsapi_security_t auth)
01089 {
01090     _auth = auth;
01091 }
01092 
01093 // Set APN, user name and password.
01094 void  UbloxATCellularInterface::set_credentials(const char *apn,
01095                                                 const char *uname,
01096                                                 const char *pwd)
01097 {
01098     _apn = apn;
01099     _uname = uname;
01100     _pwd = pwd;
01101 }
01102 
01103 // Set PIN.
01104 void UbloxATCellularInterface::set_sim_pin(const char *pin)
01105 {
01106     set_pin(pin);
01107 }
01108 
01109 // Get the IP address of a host.
01110 nsapi_error_t UbloxATCellularInterface::gethostbyname(const char *host,
01111                                                       SocketAddress *address,
01112                                                       nsapi_version_t version)
01113 {
01114     nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
01115 
01116 
01117     if (address->set_ip_address(host)) {
01118         nsapi_error = NSAPI_ERROR_OK;
01119     } else {
01120         int at_timeout;
01121         char ipAddress[NSAPI_IP_SIZE];
01122         LOCK();
01123         // This interrogation can sometimes take longer than the usual 8 seconds
01124         at_timeout = _at_timeout;
01125         at_set_timeout(60000);
01126         memset (ipAddress, 0, sizeof (ipAddress)); // Ensure terminator
01127         if (_at->send("AT+UDNSRN=0,\"%s\"", host) &&
01128             _at->recv("+UDNSRN: \"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\"", ipAddress) &&
01129             _at->recv("OK")) {
01130             if (address->set_ip_address(ipAddress)) {
01131                 nsapi_error = NSAPI_ERROR_OK;
01132             }
01133         }
01134         at_set_timeout(at_timeout);
01135         UNLOCK();
01136     }
01137 
01138     return nsapi_error;
01139 }
01140 
01141 // Make a cellular connection
01142 nsapi_error_t UbloxATCellularInterface::connect(const char *sim_pin,
01143                                                 const char *apn,
01144                                                 const char *uname,
01145                                                 const char *pwd)
01146 {
01147     nsapi_error_t nsapi_error;
01148 
01149     if (sim_pin != NULL) {
01150         _pin = sim_pin;
01151     }
01152 
01153     if (apn != NULL) {
01154         _apn = apn;
01155     }
01156 
01157     if ((uname != NULL) && (pwd != NULL)) {
01158         _uname = uname;
01159         _pwd = pwd;
01160     } else {
01161         _uname = NULL;
01162         _pwd = NULL;
01163     }
01164 
01165     nsapi_error = connect();
01166 
01167     return nsapi_error;
01168 }
01169 
01170 // Make a cellular connection using the IP stack on board the cellular modem
01171 nsapi_error_t UbloxATCellularInterface::connect()
01172 {
01173     nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
01174     bool registered = false;
01175 
01176     // Set up modem and then register with the network
01177     if (init()) {
01178         nsapi_error = NSAPI_ERROR_NO_CONNECTION;
01179         // Perform any pending SIM actions
01180         if (_sim_pin_check_change_pending) {
01181             if (!sim_pin_check_enable(_sim_pin_check_change_pending_enabled_value)) {
01182                 nsapi_error = NSAPI_ERROR_AUTH_FAILURE;
01183             }
01184             _sim_pin_check_change_pending = false;
01185         }
01186         if (_sim_pin_change_pending) {
01187             if (!change_sim_pin(_sim_pin_change_pending_new_pin_value)) {
01188                 nsapi_error = NSAPI_ERROR_AUTH_FAILURE;
01189             }
01190             _sim_pin_change_pending = false;
01191         }
01192 #ifdef TARGET_UBLOX_C030_R41XM
01193         define_context();
01194 #endif
01195         if (nsapi_error == NSAPI_ERROR_NO_CONNECTION) {
01196             for (int retries = 0; !registered && (retries < 3); retries++) {
01197                 if (nwk_registration()) {
01198                     registered = true;
01199 #ifdef TARGET_UBLOX_C030_R41XM
01200                     if(is_registered_psd() || is_registered_eps()) {
01201                         nsapi_error = NSAPI_ERROR_OK;
01202                     }
01203                     else if (activate_context()) {
01204                         nsapi_error = NSAPI_ERROR_OK;
01205                     }
01206 #endif
01207                 }
01208             }
01209         }
01210     }
01211 #ifndef TARGET_UBLOX_C030_R41XM
01212     // Attempt to establish a connection
01213     if (registered && connect_modem_stack()) {
01214         nsapi_error = NSAPI_ERROR_OK;
01215     }
01216 #endif
01217     return nsapi_error;
01218 }
01219 
01220 // User initiated disconnect.
01221 nsapi_error_t UbloxATCellularInterface::disconnect()
01222 {
01223     nsapi_error_t nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
01224 #ifdef TARGET_UBLOX_C030_R41XM
01225     if (nwk_deregistration()) {
01226         if (_connection_status_cb) {
01227             _connection_status_cb(NSAPI_ERROR_CONNECTION_LOST);
01228         }
01229 #else
01230     if (disconnect_modem_stack() && nwk_deregistration()) {
01231 #endif
01232         nsapi_error = NSAPI_ERROR_OK;
01233     }
01234 
01235     return nsapi_error;
01236 }
01237 
01238 // Enable or disable SIM PIN check lock.
01239 nsapi_error_t UbloxATCellularInterface::set_sim_pin_check(bool set,
01240                                                           bool immediate,
01241                                                           const char *sim_pin)
01242 {
01243     nsapi_error_t nsapi_error = NSAPI_ERROR_AUTH_FAILURE;
01244 
01245     if (sim_pin != NULL) {
01246         _pin = sim_pin;
01247     }
01248 
01249     if (immediate) {
01250         if (init()) {
01251             if (sim_pin_check_enable(set)) {
01252                 nsapi_error = NSAPI_ERROR_OK;
01253             }
01254         } else {
01255             nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
01256         }
01257     } else {
01258         nsapi_error = NSAPI_ERROR_OK;
01259         _sim_pin_check_change_pending = true;
01260         _sim_pin_check_change_pending_enabled_value = set;
01261     }
01262 
01263     return nsapi_error;
01264 }
01265 
01266 // Change the PIN code for the SIM card.
01267 nsapi_error_t UbloxATCellularInterface::set_new_sim_pin(const char *new_pin,
01268                                                         bool immediate,
01269                                                         const char *old_pin)
01270 {
01271     nsapi_error_t nsapi_error = NSAPI_ERROR_AUTH_FAILURE;
01272 
01273     if (old_pin != NULL) {
01274         _pin = old_pin;
01275     }
01276 
01277     if (immediate) {
01278         if (init()) {
01279             if (change_sim_pin(new_pin)) {
01280                 nsapi_error = NSAPI_ERROR_OK;
01281             }
01282         } else {
01283             nsapi_error = NSAPI_ERROR_DEVICE_ERROR;
01284         }
01285     } else {
01286         nsapi_error = NSAPI_ERROR_OK;
01287         _sim_pin_change_pending = true;
01288         _sim_pin_change_pending_new_pin_value = new_pin;
01289     }
01290 
01291     return nsapi_error;
01292 }
01293 
01294 // Determine if the connection is up.
01295 bool UbloxATCellularInterface::is_connected()
01296 {
01297     return get_ip_address() != NULL;
01298 }
01299 
01300 // Get the IP address of the on-board modem IP stack.
01301 const char * UbloxATCellularInterface::get_ip_address()
01302 {
01303     SocketAddress address;
01304     LOCK();
01305 
01306     if (_ip == NULL) {
01307         // Temporary storage for an IP address string with terminator
01308         _ip = (char *) malloc(NSAPI_IP_SIZE);
01309     }
01310 
01311     if (_ip != NULL) {
01312         memset(_ip, 0, NSAPI_IP_SIZE); // Ensure a terminator
01313         // +UPSND=<profile_id>,<param_tag>[,<dynamic_param_val>]
01314         // If we get back a quoted "w.x.y.z" then we have an IP address,
01315         // otherwise we don't.
01316 #ifdef TARGET_UBLOX_C030_R41XM
01317         if (!_at->send("AT+CGPADDR=1") ||
01318             !_at->recv("+CGPADDR: 1,%" u_stringify(NSAPI_IP_SIZE) "[^\n]\nOK\n", _ip) ||
01319             !address.set_ip_address(_ip) || // Return NULL if the address is not a valid one
01320             !address) { // Return null if the address is zero
01321             free (_ip);
01322             _ip = NULL;
01323         }
01324 #else
01325         if (!_at->send("AT+UPSND=" PROFILE ",0") ||
01326             !_at->recv("+UPSND: " PROFILE ",0,\"%" u_stringify(NSAPI_IP_SIZE) "[^\"]\"", _ip) ||
01327             !_at->recv("OK") ||
01328             !address.set_ip_address(_ip) || // Return NULL if the address is not a valid one
01329             !address) { // Return null if the address is zero
01330             free (_ip);
01331             _ip = NULL;
01332         }
01333 #endif
01334     }
01335 
01336     UNLOCK();
01337     return _ip;
01338 }
01339 
01340 // Get the local network mask.
01341 const char *UbloxATCellularInterface::get_netmask()
01342 {
01343     // Not implemented.
01344     return NULL;
01345 }
01346 
01347 // Get the local gateways.
01348 const char *UbloxATCellularInterface::get_gateway()
01349 {
01350     return get_ip_address();
01351 }
01352 
01353 // Callback in case the connection is lost.
01354 void UbloxATCellularInterface::connection_status_cb(Callback<void(nsapi_error_t)> cb)
01355 {
01356     _connection_status_cb = cb;
01357 }
01358 
01359 void UbloxATCellularInterface::set_plmn(const char *plmn) {
01360 
01361 }
01362 
01363 // End of file
01364