ATHandler.cpp

00001 /*
00002  * Copyright (c) 2017, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 #include "ATHandler.h"
00019 #include "mbed_poll.h"
00020 #include "FileHandle.h"
00021 #include "Timer.h"
00022 #include "mbed_wait_api.h"
00023 #include "mbed_debug.h"
00024 #ifdef MBED_CONF_RTOS_PRESENT
00025 #include "rtos/Thread.h"
00026 #endif
00027 
00028 using namespace mbed;
00029 using namespace events;
00030 
00031 //#define MBED_TRACE_MAX_LEVEL TRACE_LEVEL_DEBUG
00032 #include "CellularLog.h"
00033 
00034 #if MBED_CONF_MBED_TRACE_ENABLE
00035 #define at_debug(format, ...) do { if (_debug_on) debug(format, ## __VA_ARGS__); } while (0)
00036 #else
00037 #define at_debug(...)
00038 #endif
00039 
00040 const char *mbed::OK = "OK\r\n";
00041 const uint8_t OK_LENGTH = 4;
00042 const char *mbed::CRLF = "\r\n";
00043 const uint8_t CRLF_LENGTH = 2;
00044 const char *CME_ERROR = "+CME ERROR:";
00045 const uint8_t CME_ERROR_LENGTH = 11;
00046 const char *CMS_ERROR = "+CMS ERROR:";
00047 const uint8_t CMS_ERROR_LENGTH = 11;
00048 const char *ERROR_ = "ERROR\r\n";
00049 const uint8_t ERROR_LENGTH = 7;
00050 const uint8_t MAX_RESP_LENGTH = CMS_ERROR_LENGTH;
00051 const char DEFAULT_DELIMITER = ',';
00052 
00053 static const uint8_t map_3gpp_errors[][2] =  {
00054     { 103, 3 },  { 106, 6 },  { 107, 7 },  { 108, 8 },  { 111, 11 }, { 112, 12 }, { 113, 13 }, { 114, 14 },
00055     { 115, 15 }, { 122, 22 }, { 125, 25 }, { 172, 95 }, { 173, 96 }, { 174, 97 }, { 175, 99 }, { 176, 111 },
00056     { 177, 8 },  { 126, 26 }, { 127, 27 }, { 128, 28 }, { 129, 29 }, { 130, 30 }, { 131, 31 }, { 132, 32 },
00057     { 133, 33 }, { 134, 34 }, { 140, 40 }, { 141, 41 }, { 142, 42 }, { 143, 43 }, { 144, 44 }, { 145, 45 },
00058     { 146, 46 }, { 178, 65 }, { 179, 66 }, { 180, 48 }, { 181, 83 }, { 171, 49 },
00059 };
00060 
00061 ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter) :
00062     _nextATHandler(0),
00063     _fileHandle(fh),
00064     _queue(queue),
00065     _last_err(NSAPI_ERROR_OK ),
00066     _last_3gpp_error(0),
00067     _oob_string_max_length(0),
00068     _oobs(NULL),
00069     _at_timeout(timeout),
00070     _previous_at_timeout(timeout),
00071     _fh_sigio_set(false),
00072     _processing(false),
00073     _ref_count(1),
00074     _stop_tag(NULL),
00075     _delimiter(DEFAULT_DELIMITER),
00076     _prefix_matched(false),
00077     _urc_matched(false),
00078     _error_found(false),
00079     _max_resp_length(MAX_RESP_LENGTH),
00080     _debug_on(false),
00081     _cmd_start(false)
00082 {
00083     //enable_debug(true);
00084 
00085     clear_error();
00086 
00087     if (output_delimiter) {
00088         _output_delimiter_length = strlen(output_delimiter);
00089         _output_delimiter = new char[_output_delimiter_length];
00090         for (unsigned i=0; i<_output_delimiter_length; i++) {
00091             _output_delimiter[i] = output_delimiter[i];
00092         }
00093     } else {
00094         _output_delimiter = NULL;
00095         _output_delimiter_length = 0;
00096     }
00097 
00098     reset_buffer();
00099     memset(_info_resp_prefix, 0, sizeof(_info_resp_prefix));
00100 
00101     _current_scope = NotSet;
00102     set_tag(&_resp_stop, OK);
00103     set_tag(&_info_stop, CRLF);
00104     set_tag(&_elem_stop, ")");
00105 
00106     _fileHandle->set_blocking(false);
00107 
00108     set_filehandle_sigio();
00109 }
00110 
00111 void ATHandler::enable_debug(bool enable)
00112 {
00113     _debug_on = enable;
00114 }
00115 
00116 ATHandler::~ATHandler()
00117 {
00118     while (_oobs) {
00119         struct oob_t *oob = _oobs;
00120         _oobs = oob->next;
00121         delete oob;
00122     }
00123     if (_output_delimiter) {
00124         delete [] _output_delimiter;
00125     }
00126 }
00127 
00128 void ATHandler::inc_ref_count()
00129 {
00130     _ref_count++;
00131 }
00132 
00133 void ATHandler::dec_ref_count()
00134 {
00135     _ref_count--;
00136 }
00137 
00138 int ATHandler::get_ref_count()
00139 {
00140     return _ref_count;
00141 }
00142 
00143 FileHandle *ATHandler::get_file_handle()
00144 {
00145     return _fileHandle;
00146 }
00147 
00148 void ATHandler::set_file_handle(FileHandle *fh)
00149 {
00150     _fileHandle = fh;
00151 }
00152 
00153 void ATHandler::set_urc_handler(const char *prefix, mbed::Callback<void()> callback)
00154 {
00155     struct oob_t *oob = new struct oob_t;
00156     oob->matching_to_received = true;
00157     size_t prefix_len = strlen(prefix);
00158     if (prefix_len > _oob_string_max_length) {
00159         _oob_string_max_length = prefix_len;
00160         if (_oob_string_max_length > _max_resp_length) {
00161             _max_resp_length = _oob_string_max_length;
00162         }
00163     }
00164     oob->prefix = prefix;
00165     oob->cb = callback;
00166     oob->next = _oobs;
00167     _oobs = oob;
00168 }
00169 
00170 void ATHandler::event()
00171 {
00172     // _processing must be set before filehandle write/read to avoid repetitive sigio events
00173     if (!_processing) {
00174         _processing = true;
00175         (void) _queue.call(Callback<void(void)>(this, &ATHandler::process_oob));
00176     }
00177 }
00178 
00179 void ATHandler::lock()
00180 {
00181 #ifdef AT_HANDLER_MUTEX
00182     _fileHandleMutex.lock();
00183 #endif
00184     _processing = true;
00185     clear_error();
00186 }
00187 
00188 void ATHandler::unlock()
00189 {
00190     _processing = false;
00191 #ifdef AT_HANDLER_MUTEX
00192     _fileHandleMutex.unlock();
00193 #endif
00194     if (_fileHandle->readable() || (_recv_pos < _recv_len)) {
00195         (void) _queue.call(Callback<void(void)>(this, &ATHandler::process_oob));
00196     }
00197 }
00198 
00199 nsapi_error_t ATHandler::unlock_return_error()
00200 {
00201     nsapi_error_t err = _last_err;
00202     unlock();
00203     return err;
00204 }
00205 
00206 void ATHandler::set_at_timeout(uint32_t timeout_milliseconds, bool default_timeout)
00207 {
00208     if (default_timeout) {
00209         _previous_at_timeout = timeout_milliseconds;
00210         _at_timeout = timeout_milliseconds;
00211     } else if (timeout_milliseconds != _at_timeout) {
00212         _previous_at_timeout = _at_timeout;
00213         _at_timeout = timeout_milliseconds;
00214     }
00215 }
00216 
00217 void ATHandler::restore_at_timeout()
00218 {
00219     if (_previous_at_timeout != _at_timeout) {
00220         _at_timeout =_previous_at_timeout;
00221     }
00222 }
00223 
00224 void ATHandler::process_oob()
00225 {
00226     lock();
00227     tr_debug("process_oob %d", (_fileHandle->readable() || (_recv_pos < _recv_len)));
00228     if (_fileHandle->readable() || (_recv_pos < _recv_len)) {
00229         _current_scope = NotSet;
00230         Timer timer;
00231         timer.start();
00232         do {
00233             if (match_urc()) {
00234                 if (_fileHandle->readable() || (_recv_pos < _recv_len)) {
00235                     continue;
00236                 }
00237                 break;
00238             }
00239             // If no match found, look for CRLF and consume everything up to CRLF
00240             if (mem_str(_recv_buff, _recv_len, CRLF, CRLF_LENGTH)) {
00241                 consume_to_tag(CRLF, true);
00242             } else {
00243                 if (_fileHandle->readable()) {
00244                     fill_buffer();
00245                 } else {
00246 #ifdef MBED_CONF_RTOS_PRESENT
00247                     rtos::Thread::yield();
00248 #endif
00249                 }
00250             }
00251         } while (timer.read_ms() < 20); // URC's are very short so 20ms should be enough
00252     }
00253     tr_debug("process_oob exit");
00254 
00255     flush(); // consume anything that could not be handled
00256 
00257     unlock();
00258 }
00259 
00260 void ATHandler::set_filehandle_sigio()
00261 {
00262     if (_fh_sigio_set) {
00263         return;
00264     }
00265     _fileHandle->sigio(mbed::Callback<void()>(this, &ATHandler::event));
00266     _fh_sigio_set = true;
00267 }
00268 
00269 void ATHandler::reset_buffer()
00270 {
00271     tr_debug("%s", __func__);
00272     _recv_pos = 0; _recv_len = 0;
00273 }
00274 
00275 void ATHandler::rewind_buffer()
00276 {
00277     tr_debug("%s", __func__);
00278     if (_recv_pos > 0 && _recv_len >= _recv_pos) {
00279         _recv_len -= _recv_pos;
00280         // move what is not read to beginning of buffer
00281         memmove(_recv_buff, _recv_buff + _recv_pos, _recv_len);
00282         _recv_pos = 0;
00283     }
00284 }
00285 
00286 // we are always expecting to receive something so there is wait timeout
00287 void ATHandler::fill_buffer()
00288 {
00289     tr_debug("%s", __func__);
00290     // Reset buffer when full
00291     if (sizeof(_recv_buff) == _recv_len) {
00292         reset_buffer();
00293     }
00294 
00295     Timer timer;
00296     timer.start();
00297     do {
00298        ssize_t len = _fileHandle->read(_recv_buff + _recv_len, sizeof(_recv_buff) - _recv_len);
00299         if (len > 0) {
00300             _recv_len += len;
00301            at_debug("\n----------readable----------: %d\n", _recv_len);
00302            for (size_t i = _recv_pos; i < _recv_len; i++) {
00303                at_debug("%c", _recv_buff[i]);
00304            }
00305            at_debug("\n----------readable----------\n");
00306            return;
00307        } else if (len != -EAGAIN && len != 0) {
00308            tr_warn("%s error: %d while reading", __func__, len);
00309            break;
00310        }
00311 #ifdef MBED_CONF_RTOS_PRESENT
00312         rtos::Thread::yield();
00313 #endif
00314     } while ((uint32_t)timer.read_ms() < _at_timeout);
00315 
00316     set_error(NSAPI_ERROR_DEVICE_ERROR );
00317     tr_debug("AT TIMEOUT, scope: %d timeout: %lu", _current_scope, _at_timeout);
00318 }
00319 
00320 int ATHandler::get_char()
00321 {
00322     if (_recv_pos == _recv_len) {
00323         tr_debug("%s", __func__);
00324         reset_buffer(); // try to read as much as possible
00325         fill_buffer();
00326         if (get_last_error()) {
00327             tr_debug("%s: -1", __func__);
00328             return -1; // timeout to read
00329         }
00330     }
00331 
00332     tr_debug("%s: %c", __func__, _recv_buff[_recv_pos]);
00333 
00334     return _recv_buff[_recv_pos++];
00335 }
00336 
00337 void ATHandler::skip_param(uint32_t count)
00338 {
00339     tr_debug("%s", __func__);
00340     if (_last_err || !_stop_tag || _stop_tag->found) {
00341         return;
00342     }
00343 
00344     for (uint32_t i = 0; (i < count && !_stop_tag->found); i++) {
00345         size_t match_pos = 0;
00346         while (true) {
00347             int c = get_char();
00348             if (c == -1) {
00349                 set_error(NSAPI_ERROR_DEVICE_ERROR );
00350                 return;
00351             } else if (c == _delimiter) {
00352                 break;
00353             } else if (_stop_tag->len && c == _stop_tag->tag[match_pos]) {
00354                 match_pos++;
00355                 if (match_pos == _stop_tag->len) {
00356                     _stop_tag->found = true;
00357                     break;
00358                 }
00359             } else if (match_pos) {
00360                 match_pos = 0;
00361             }
00362         }
00363     }
00364     return;
00365 }
00366 
00367 void ATHandler::skip_param(ssize_t len, uint32_t count)
00368 {
00369     tr_debug("%s", __func__);
00370     if (_last_err || !_stop_tag || _stop_tag->found) {
00371         return;
00372     }
00373 
00374     for (uint32_t i = 0; i < count; i++) {
00375         ssize_t read_len = 0;
00376         while (read_len < len) {
00377             int c = get_char();
00378             if (c == -1) {
00379                 set_error(NSAPI_ERROR_DEVICE_ERROR );
00380                 return;
00381             }
00382             read_len++;
00383         }
00384     }
00385     return;
00386 }
00387 
00388 ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len)
00389 {
00390     tr_debug("%s", __func__);
00391     if (_last_err) {
00392         return -1;
00393     }
00394 
00395     size_t read_len = 0;
00396     for (; read_len < len; read_len++) {
00397         int c = get_char();
00398         if (c == -1) {
00399             set_error(NSAPI_ERROR_DEVICE_ERROR );
00400             return -1;
00401         }
00402         buf[read_len] = c;
00403     }
00404     return read_len;
00405 }
00406 
00407 ssize_t ATHandler::read_string(char *buf, size_t size, bool read_even_stop_tag)
00408 {
00409     tr_debug("%s", __func__);
00410     at_debug("\n----------read_string buff:----------\n");
00411     for (size_t i = _recv_pos; i < _recv_len; i++) {
00412         at_debug("%c", _recv_buff[i]);
00413     }
00414     at_debug("\n----------buff----------\n");
00415 
00416     if (_last_err || !_stop_tag || (_stop_tag->found && read_even_stop_tag == false)) {
00417         return -1;
00418     }
00419 
00420     uint8_t *pbuf = (uint8_t*)buf;
00421 
00422     size_t len = 0;
00423     size_t match_pos = 0;
00424 
00425     consume_char('\"');
00426 
00427     for (; len < (size + match_pos); len++) {
00428         int c = get_char();
00429         if (c == -1) {
00430             pbuf[len] = '\0';
00431             set_error(NSAPI_ERROR_DEVICE_ERROR );
00432             return -1;
00433         } else if (c == _delimiter) {
00434             pbuf[len] = '\0';
00435             break;
00436         } else if (c == '\"') {
00437             match_pos = 0;
00438             len--;
00439             continue;
00440         } else if (_stop_tag->len && c == _stop_tag->tag[match_pos]) {
00441             match_pos++;
00442             if (match_pos == _stop_tag->len) {
00443                 _stop_tag->found = true;
00444                 // remove tag from string if it was matched
00445                 len -= (_stop_tag->len - 1);
00446                 pbuf[len] = '\0';
00447                 break;
00448             }
00449         } else if (match_pos) {
00450             match_pos = 0;
00451         }
00452 
00453         pbuf[len] = c;
00454     }
00455 
00456     // Do we need _stop_found set after reading by size -> is _stop_tag_by_len needed or not?
00457     return len;
00458 }
00459 
00460 int32_t ATHandler::read_int()
00461 {
00462     tr_debug("%s", __func__);
00463 
00464      if (_last_err || !_stop_tag || _stop_tag->found) {
00465          return -1;
00466      }
00467 
00468     char buff[BUFF_SIZE];
00469     char *first_no_digit;
00470 
00471     if (read_string(buff, (size_t)sizeof(buff)) == 0) {
00472         return -1;
00473     }
00474 
00475     return std::strtol(buff, &first_no_digit, 10);
00476 }
00477 
00478 void ATHandler::set_delimiter(char delimiter)
00479 {
00480     _delimiter = delimiter;
00481 }
00482 
00483 void ATHandler::set_default_delimiter()
00484 {
00485     _delimiter = DEFAULT_DELIMITER;
00486 }
00487 
00488 void ATHandler::set_tag(tag_t* tag_dst, const char *tag_seq)
00489 {
00490     if (tag_seq) {
00491         size_t tag_len = strlen(tag_seq);
00492         set_string(tag_dst->tag, tag_seq, tag_len);
00493         tag_dst->len = tag_len;
00494         tag_dst->found = false;
00495     } else {
00496         _stop_tag = NULL;
00497     }
00498 }
00499 
00500 void ATHandler::set_stop_tag(const char *stop_tag_seq)
00501 {
00502     if (_last_err || !_stop_tag) {
00503         return;
00504     }
00505 
00506     set_tag(_stop_tag, stop_tag_seq);
00507 }
00508 
00509 void ATHandler::set_scope(ScopeType scope_type)
00510 {
00511     tr_debug("%s: %d", __func__, scope_type);
00512     if (_current_scope != scope_type) {
00513         _current_scope = scope_type;
00514         switch (_current_scope) {
00515         case RespType:
00516             _stop_tag = &_resp_stop;
00517             _stop_tag->found = false;
00518             break;
00519         case InfoType:
00520             _stop_tag = &_info_stop;
00521             _stop_tag->found = false;
00522             consume_char(' ');
00523             break;
00524         case ElemType:
00525             _stop_tag = &_elem_stop;
00526             _stop_tag->found = false;
00527             break;
00528         case NotSet:
00529             _stop_tag = NULL;
00530             return;
00531         default:
00532             break;
00533         }
00534     }
00535 }
00536 
00537 // should match from recv_pos?
00538 bool ATHandler::match(const char* str, size_t size)
00539 {
00540     tr_debug("%s: %s", __func__, str);
00541     rewind_buffer();
00542 
00543     if ((_recv_len - _recv_pos) < size) {
00544         return false;
00545     }
00546 
00547     if (str && memcmp(_recv_buff + _recv_pos, str, size) == 0) {
00548         // consume matching part
00549         _recv_pos += size;
00550         return true;
00551     }
00552     return false;
00553 }
00554 
00555 bool ATHandler::match_urc()
00556 {
00557     tr_debug("%s", __func__);
00558     rewind_buffer();
00559     size_t prefix_len = 0;
00560     for (struct oob_t *oob = _oobs; oob; oob = oob->next) {
00561         prefix_len = strlen(oob->prefix);
00562         if (_recv_len >= prefix_len) {
00563             if (match(oob->prefix, prefix_len)) {
00564                 tr_debug("URC! %s", oob->prefix);
00565                 set_scope(InfoType);
00566                 if (oob->cb) {
00567                     oob->cb();
00568                 }
00569                 information_response_stop();
00570                 return true;
00571             }
00572         }
00573     }
00574     return false;
00575 }
00576 
00577 bool ATHandler::match_error()
00578 {
00579     tr_debug("%s", __func__);
00580 
00581     if (match(CME_ERROR, CME_ERROR_LENGTH)) {
00582         at_error(true, DeviceErrorTypeErrorCME);
00583         return true;
00584     } else if (match(CMS_ERROR, CMS_ERROR_LENGTH)) {
00585         at_error(true, DeviceErrorTypeErrorCMS);
00586         return true;
00587     } else if (match(ERROR_, ERROR_LENGTH)) {
00588         at_error(false, DeviceErrorTypeNoError);
00589         return true;
00590     }
00591 
00592     return false;
00593 }
00594 
00595 void ATHandler::clear_error()
00596 {
00597     _last_err = NSAPI_ERROR_OK ;
00598     _last_at_err.errCode = 0;
00599     _last_at_err.errType = DeviceErrorTypeNoError;
00600     _last_3gpp_error = 0;
00601 }
00602 
00603 nsapi_error_t ATHandler::get_last_error() const
00604 {
00605     return _last_err;
00606 }
00607 
00608 device_err_t ATHandler::get_last_device_error() const
00609 {
00610     return _last_at_err;
00611 }
00612 
00613 void ATHandler::set_error(nsapi_error_t err)
00614 {
00615     if (_last_err == NSAPI_ERROR_OK ) {
00616         _last_err = err;
00617     }
00618 
00619     if (_last_err != err) {
00620         tr_warn("AT error code changed from %d to %d!", _last_err, err);
00621     }
00622 }
00623 
00624 int ATHandler::get_3gpp_error()
00625 {
00626     return _last_3gpp_error;
00627 }
00628 
00629 void ATHandler::set_3gpp_error(int err, DeviceErrorType error_type)
00630 {
00631     if (_last_3gpp_error) { // don't overwrite likely root cause error
00632         return;
00633     }
00634 
00635     if (error_type == DeviceErrorTypeErrorCMS && err < 128) {
00636         // CMS errors 0-127 maps straight to 3GPP errors
00637         _last_3gpp_error = err;
00638     } else {
00639         for (size_t i = 0; i<sizeof(map_3gpp_errors)/sizeof(map_3gpp_errors[0]); i++) {
00640             if (map_3gpp_errors[i][0] == err) {
00641                 _last_3gpp_error = map_3gpp_errors[i][1];
00642                 tr_debug("AT3GPP error code %d", get_3gpp_error());
00643                 break;
00644             }
00645         }
00646     }
00647 }
00648 
00649 void ATHandler::at_error(bool error_code_expected, DeviceErrorType error_type)
00650 {
00651     int32_t err = -1;
00652 
00653     if (error_code_expected && (error_type == DeviceErrorTypeErrorCMS || error_type == DeviceErrorTypeErrorCME)) {
00654         set_scope(InfoType);
00655         err = read_int();
00656 
00657         if (err != -1) {
00658             set_3gpp_error(err, error_type);
00659             _last_at_err.errCode = err;
00660             _last_at_err.errType = error_type;
00661             tr_debug("ATHandler ERROR: %d", err);
00662         } else {
00663             tr_debug("ATHandler ERROR reading failed");
00664         }
00665     }
00666 
00667     _last_err = NSAPI_ERROR_DEVICE_ERROR ;
00668 }
00669 
00670 void ATHandler::resp(const char *prefix, bool check_urc)
00671 {
00672     tr_debug("%s: %s", __func__, prefix);
00673 
00674     at_debug("\n----------resp buff:----------\n");
00675     for (size_t i = _recv_pos; i < _recv_len; i++) {
00676         at_debug("%c", _recv_buff[i]);
00677     }
00678     at_debug("\n----------buff----------\n");
00679 
00680     _prefix_matched = false;
00681     _urc_matched = false;
00682     _error_found = false;
00683 
00684     while (!get_last_error()) {
00685 
00686         match(CRLF, CRLF_LENGTH);
00687 
00688         if (match(OK, OK_LENGTH)) {
00689             set_scope(RespType);
00690             _stop_tag->found = true;
00691             return;
00692         }
00693 
00694         if (match_error()) {
00695             _error_found = true;
00696             return;
00697         }
00698 
00699         if (prefix && match(prefix, strlen(prefix))) {
00700             _prefix_matched = true;
00701             return;
00702         }
00703 
00704         if (check_urc && match_urc()) {
00705             _urc_matched = true;
00706         }
00707 
00708         // If no match found, look for CRLF and consume everything up to and including CRLF
00709         if (mem_str(_recv_buff, _recv_len, CRLF, CRLF_LENGTH)) {
00710             // If no prefix, return on CRLF - means data to read
00711             if (!prefix) {
00712                 return;
00713             }
00714             consume_to_tag(CRLF, true);
00715         } else {
00716             // If no prefix, no CRLF and no more chance to match for OK, ERROR or URC(since max resp length is already in buffer)
00717             // return so data could be read
00718             if (!prefix && ((_recv_len-_recv_pos) >= _max_resp_length)) {
00719                 return;
00720             }
00721             fill_buffer();
00722         }
00723     }
00724 
00725     return;
00726     // something went wrong so application need to recover and retry
00727 }
00728 
00729 void ATHandler::resp_start(const char *prefix, bool stop)
00730 {
00731     tr_debug("%s: %s", __func__, prefix);
00732 
00733     if (_last_err) {
00734         return;
00735     }
00736 
00737     // Try get as much data as possible
00738     rewind_buffer();
00739     fill_buffer();
00740 
00741     if (prefix) {
00742         if ((strlen(prefix) < sizeof(_info_resp_prefix))) {
00743             strcpy(_info_resp_prefix, prefix);
00744         } else {
00745             MBED_ASSERT(0);
00746         }
00747     }
00748 
00749     set_scope(RespType);
00750 
00751     resp(prefix, true);
00752 
00753     if (!stop && prefix && _prefix_matched) {
00754         set_scope(InfoType);
00755     }
00756 }
00757 
00758 // check urc because of error as urc
00759 bool ATHandler::info_resp()
00760 {
00761     tr_debug("%s", __func__);
00762     if (_last_err || _resp_stop.found) {
00763         return false;
00764     }
00765 
00766     if (_prefix_matched) {
00767         _prefix_matched = false;
00768        return true;
00769     }
00770 
00771     // If coming here after another info response was started(looping), stop the previous one.
00772     // Trying to handle stopping in this level instead of doing it in upper level.
00773     if (get_scope() == InfoType) {
00774         information_response_stop();
00775     }
00776 
00777     resp(_info_resp_prefix, false);
00778 
00779     if (_prefix_matched) {
00780        set_scope(InfoType);
00781        _prefix_matched = false;
00782        return true;
00783     }
00784 
00785     // On mismatch go to response scope
00786     set_scope(RespType);
00787     return false;
00788 }
00789 
00790 bool ATHandler::info_elem(char start_tag)
00791 {
00792     tr_debug("%s: %c", __func__, start_tag);
00793     if (_last_err) {
00794         return false;
00795     }
00796 
00797     // If coming here after another info response element was started(looping), stop the previous one.
00798     // Trying to handle stopping in this level instead of doing it in upper level.
00799     if (get_scope() == ElemType) {
00800         information_response_element_stop();
00801     }
00802 
00803     consume_char(_delimiter);
00804 
00805     if (consume_char(start_tag)) {
00806         _prefix_matched = true;
00807         set_scope(ElemType);
00808         return true;
00809     }
00810 
00811     // On mismatch go to information response scope
00812     set_scope(InfoType);
00813     return false;
00814 }
00815 
00816 bool ATHandler::consume_char(char ch)
00817 {
00818     tr_debug("%s: %c", __func__, ch);
00819     int read_char = get_char();
00820     // If we read something else than ch, recover it
00821     if (read_char != ch && read_char != -1) {
00822         _recv_pos--;
00823         return false;
00824     }
00825     return true;
00826 }
00827 
00828 bool ATHandler::consume_to_tag(const char *tag, bool consume_tag)
00829 {
00830     tr_debug("%s: %s", __func__, tag);
00831     size_t match_pos = 0;
00832 
00833     while (true) {
00834         int c = get_char();
00835         if (c == -1) {
00836             break;
00837         } else if (c == tag[match_pos]) {
00838             match_pos++;
00839             if (match_pos == strlen(tag)) {
00840                 if (!consume_tag) {
00841                     _recv_pos -= strlen(tag);
00842                 }
00843                 return true;
00844             }
00845         } else if (match_pos) {
00846             match_pos = 0;
00847         }
00848     }
00849     tr_debug("consume_to_tag not found");
00850     return false;
00851 }
00852 
00853 bool ATHandler::consume_to_stop_tag()
00854 {
00855     tr_debug("%s", __func__);
00856 
00857     if (!_stop_tag || (_stop_tag && _stop_tag->found) || _error_found) {
00858         return true;
00859     }
00860 
00861     if (consume_to_tag((const char*)_stop_tag->tag, true)) {
00862         return true;
00863     }
00864 
00865     tr_debug("consume_to_stop_tag not found");
00866     set_error(NSAPI_ERROR_DEVICE_ERROR );
00867     return false;
00868 }
00869 
00870 // consume by size needed?
00871 
00872 void ATHandler::resp_stop()
00873 {
00874     // Do not return on error so that we can consume whatever there is in the buffer
00875 
00876     tr_debug("%s", __func__);
00877 
00878     if (_current_scope == ElemType) {
00879         information_response_element_stop();
00880         set_scope(InfoType);
00881     }
00882 
00883     if (_current_scope == InfoType) {
00884         information_response_stop();
00885     }
00886 
00887     // Go for response stop_tag
00888     if (consume_to_stop_tag()) {
00889         set_scope(NotSet);
00890     }
00891 
00892     // Restore stop tag to OK
00893     set_tag(&_resp_stop, OK);
00894     // Reset info resp prefix
00895     memset(_info_resp_prefix, 0, sizeof(_info_resp_prefix));
00896 }
00897 
00898 void ATHandler::information_response_stop()
00899 {
00900     tr_debug("%s", __func__);
00901     if (consume_to_stop_tag()) {
00902         set_scope(RespType);
00903     }
00904 }
00905 
00906 void ATHandler::information_response_element_stop()
00907 {
00908     tr_debug("%s", __func__);
00909     if (consume_to_stop_tag()) {
00910         set_scope(InfoType);
00911     }
00912 }
00913 
00914 ATHandler::ScopeType ATHandler::get_scope()
00915 {
00916     return _current_scope;
00917 }
00918 
00919 void ATHandler::set_string(char *dest, const char *src, size_t src_len)
00920 {
00921     memcpy(dest, src, src_len);
00922     dest[src_len] = '\0';
00923 }
00924 
00925 const char* ATHandler::mem_str(const char* dest, size_t dest_len, const char* src, size_t src_len)
00926 {
00927     if (dest_len > src_len) {
00928         for(size_t i = 0; i < dest_len-src_len+1; ++i) {
00929             if(memcmp(dest+i, src, src_len) == 0) {
00930                 return dest+i;
00931             }
00932         }
00933     }
00934     return NULL;
00935 }
00936 
00937 void ATHandler::cmd_start(const char* cmd)
00938 {
00939     tr_debug("AT> %s", cmd);
00940 
00941     if (_last_err != NSAPI_ERROR_OK ) {
00942         return;
00943     }
00944 
00945     (void)write(cmd, strlen(cmd));
00946 
00947     _cmd_start = true;
00948 }
00949 
00950 void ATHandler::write_int(int32_t param)
00951 {
00952     tr_debug("write_int: %d", param);
00953     // do common checks before sending subparameter
00954     if (check_cmd_send() == false) {
00955         return;
00956     }
00957 
00958     // write the integer subparameter
00959     const int32_t str_len = 12;
00960     char number_string[str_len];
00961     int32_t result = sprintf(number_string, "%ld", param);
00962     if (result > 0 && result < str_len) {
00963         (void)write(number_string, strlen(number_string));
00964     }
00965 }
00966 
00967 void ATHandler::write_string(const char* param, bool useQuotations)
00968 {
00969     tr_debug("write_string: %s, %d", param, useQuotations);
00970     // do common checks before sending subparameter
00971     if (check_cmd_send() == false) {
00972         return;
00973     }
00974 
00975     // we are writing string, surround it with quotes
00976     if (useQuotations && write("\"", 1) != 1) {
00977         return;
00978     }
00979 
00980     (void)write(param, strlen(param));
00981 
00982     if (useQuotations) {
00983         // we are writing string, surround it with quotes
00984         (void)write("\"", 1);
00985     }
00986 }
00987 
00988 void ATHandler::cmd_stop()
00989 {
00990     if (_last_err != NSAPI_ERROR_OK ) {
00991         return;
00992     }
00993      // Finish with CR
00994     (void)write(_output_delimiter, _output_delimiter_length);
00995 }
00996 
00997 size_t ATHandler::write_bytes(const uint8_t *data, size_t len)
00998 {
00999     if (_last_err != NSAPI_ERROR_OK ) {
01000         return 0;
01001     }
01002 
01003     ssize_t write_len = write(data, len);
01004     return write_len < 0 ? 0 : (size_t)write_len;
01005 }
01006 
01007 ssize_t ATHandler::write(const void *data, size_t len)
01008 {
01009     pollfh fhs;
01010     fhs.fh = _fileHandle;
01011     fhs.events = POLLOUT;
01012     ssize_t write_len = -1;
01013 
01014     int count = poll(&fhs, 1, _at_timeout);
01015     if (count > 0 && (fhs.revents & POLLOUT)) {
01016         write_len = _fileHandle->write(data, len);
01017     }
01018 
01019     if (write_len < 0 || (size_t)write_len != len) {
01020         set_error(NSAPI_ERROR_DEVICE_ERROR );
01021     }
01022 
01023     return write_len;
01024 }
01025 
01026 // do common checks before sending subparameters
01027 bool ATHandler::check_cmd_send()
01028 {
01029     if (_last_err != NSAPI_ERROR_OK ) {
01030         return false;
01031     }
01032 
01033     // Don't write delimiter if this is the first subparameter
01034     if (_cmd_start) {
01035         _cmd_start = false;
01036     } else {
01037         if (write(&_delimiter, 1) != 1) {
01038             // writing of delimiter failed, return. write() already have set the _last_err
01039             return false;
01040         }
01041     }
01042 
01043     return true;
01044 }
01045 
01046 void ATHandler::flush()
01047 {
01048     while (_fileHandle->readable()) {
01049         reset_buffer();
01050         fill_buffer();
01051     }
01052     reset_buffer();
01053 }