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