bool AtDrv::setWiFiConfig(char *ssid, int type, const char * password, long timeout) { bool ret = false; char wifiConfBuf[MAX_WIFI_CONF_BUF_SIZE]; char conSetting[MAX_TEMP_BUF_SIZE]; if(type == ENC_TYPE_NONE) sprintf(conSetting, "%s,none,", ssid); else if(type == ENC_TYPE_WEP_OPEN) sprintf(conSetting, "%s,wep_open,%s", ssid, password); else sprintf(conSetting, "%s,auto,%s", ssid, password); sprintf(wifiConfBuf, at_wifi_conf, conSetting); clearSerialRxData(); INFO1(wifiConfBuf); serialPort[0]->print(wifiConfBuf); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->find(wifiConfBuf) || !serialPort[0]->find(at_ok)) { INFO1("Fail to set wifi conf"); goto end; } ret = true; end: return ret; }
void AtDrv::getFwVersion(char fwVersion[], uint8_t bufLength, long timeout) { int bytes; if(!isAtMode()) { if(!switchToAtMode()) { INFO1("Can't switch to at mode"); goto end; } } clearSerialRxData(); INFO1(at_ver); serialPort[0]->print(at_ver); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); // skip cmd response and '\n' if(!serialPort[0]->find(at_ver) || !serialPort[0]->find("\n")) { INFO1("fail to get firmware version"); goto end; } bytes = serialPort[0]->readBytesUntil('\r', fwVersion, bufLength); fwVersion[bytes] = NULL; end: clearSerialRxData(); return; }
int format_get_plugin (format_plugin_t *plugin) { int ret = -1; if (plugin->_state) { INFO1 ("internal format details already created for %s", plugin->mount); return 0; } switch (plugin->type) { case FORMAT_TYPE_OGG: ret = format_ogg_get_plugin (plugin); break; case FORMAT_TYPE_AAC: case FORMAT_TYPE_MPEG: ret = format_mp3_get_plugin (plugin); break; case FORMAT_TYPE_EBML: ret = format_ebml_get_plugin (plugin); break; default: INFO1 ("unparsed format detected for %s", plugin->mount); break; } return ret; }
bool AtDrv::setNetDns(uint32_t dns1, uint32_t dns2, long timeout) { bool ret = false; char netDnsBuf[MAX_DHCPD_IP_BUF_SIZE]; char tempBuf[MAX_DHCPD_IP_BUF_SIZE]; char dns1Buf[MAX_IP_BUF_SIZE]; char dns2Buf[MAX_IP_BUF_SIZE]; uint8_t *pIp = (uint8_t*) &dns1; sprintf(dns1Buf, "%u.%u.%u.%u", pIp[0], pIp[1], pIp[2], pIp[3]); pIp = (uint8_t*) &dns2; sprintf(dns2Buf, "%u.%u.%u.%u", pIp[0], pIp[1], pIp[2], pIp[3]); sprintf(tempBuf, "%s,%s", dns1Buf, dns2Buf); sprintf(netDnsBuf, at_net_dns, tempBuf); clearSerialRxData(); INFO1(netDnsBuf); serialPort[0]->print(netDnsBuf); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->find(netDnsBuf) || !serialPort[0]->find(at_ok)) { INFO1("Fail to set dhcpd dns"); goto end; } ret = true; end: return ret; }
bool AtDrv::isWiFiConnected(long timeout) { bool ret = false; byte respBuf[MAX_RESP_BUF_SIZE]; if(!isAtMode()) { if(!switchToAtMode()) { INFO1("Can't switch to at mode"); goto end; } } clearSerialRxData(); INFO1(at_wifi_ConState); serialPort[0]->print(at_wifi_ConState); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->find(at_Connected)) { INFO1("Not Connected"); goto end; } ret = true; end: return ret; }
void AtDrv::getLocalIp(uint8_t *ip, long timeout) { clearSerialRxData(); INFO1(at_get_ip); serialPort[0]->print(at_get_ip); serialPort[0]->print("\r\r"); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); // skip cmd response if(!serialPort[0]->find(at_get_ip)) { INFO1("fail to get local IP"); ip[0] = ip[1] = ip[2] = ip[3] = 0; goto end; } ip[0] = serialPort[0]->parseInt(); ip[1] = serialPort[0]->parseInt(); ip[2] = serialPort[0]->parseInt(); ip[3] = serialPort[0]->parseInt(); INFO("Local IP: %d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]); end: clearSerialRxData(); return; }
bool AtDrv::getRemotePort(uint8_t sock, uint16_t *port, long timeout) { bool ret = false; char cmdBuf[MAX_CMD_BUF_SIZE]; sprintf(cmdBuf, at_remoteport[sock], "?"); clearSerialRxData(); INFO1(cmdBuf); serialPort[0]->print(cmdBuf); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->find(cmdBuf)) { INFO1("fail to get remote port"); *port = 0; goto end; } *port = serialPort[0]->parseInt(); INFO("Remote port: %d", *port); clearSerialRxData(); ret = true; end: return ret; }
/** Receiver function */ int slave(int argc, char *argv[]) { m_task_t task = NULL; int res; int id = -1; xbt_assert1(sscanf(argv[1],"%d", &id), "Invalid argument %s\n",argv[1]); MSG_process_sleep(1); /* Make sure the master is done creating the mailboxes */ while(1) { res = MSG_mailbox_get_task_ext(mb[id], &(task), NULL, -1); xbt_assert0(res == MSG_OK, "MSG_task_get failed"); INFO1("Received \"%s\"", MSG_task_get_name(task)); if (!strcmp(MSG_task_get_name(task),"finalize")) { MSG_task_destroy(task); break; } INFO1("Processing \"%s\"", MSG_task_get_name(task)); MSG_task_execute(task); INFO1("\"%s\" done", MSG_task_get_name(task)); MSG_task_destroy(task); task = NULL; } INFO0("I'm done. See you!"); return 0; } /* end_of_slave */
bool AtDrv::getRemoteIp(uint8_t sock, uint8_t *ip, long timeout) { bool ret = false; char cmdBuf[MAX_CMD_BUF_SIZE]; sprintf(cmdBuf, at_remoteip[sock], "?"); clearSerialRxData(); INFO1(cmdBuf); serialPort[0]->print(cmdBuf); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->findUntil(cmdBuf, "\r\n")) { INFO1("fail to get remote IP"); ip[0] = ip[1] = ip[2] = ip[3] = 0; goto end; } ip[0] = serialPort[0]->parseInt(); ip[1] = serialPort[0]->parseInt(); ip[2] = serialPort[0]->parseInt(); ip[3] = serialPort[0]->parseInt(); INFO("Remote IP: %d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]); clearSerialRxData(); ret = true; end: return ret; }
int32_t AtDrv::getCurrentRSSI(long timeout) { int32_t rssi = 0; clearSerialRxData(); INFO1(at_get_rssi); serialPort[0]->print(at_get_rssi); serialPort[0]->print("\r\r"); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); // skip cmd response if(!serialPort[0]->find(at_get_rssi)) { INFO1("fail to get rssi"); goto end; } // this is link qualit value (0~100) rssi = serialPort[0]->parseInt(); // convert link quality to dbm rssi = (rssi/2) - 100; INFO("RSSI: %ld dbm", rssi); end: clearSerialRxData(); return rssi; }
void AtDrv::getNetmask(uint8_t *mask, long timeout) { clearSerialRxData(); INFO1(at_get_mask); serialPort[0]->print(at_get_mask); serialPort[0]->print("\r\r"); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); // skip cmd response if(!serialPort[0]->find(at_get_mask)) { INFO1("fail to get netmask"); mask[0] = mask[1] = mask[2] = mask[3] = 0; goto end; } mask[0] = serialPort[0]->parseInt(); mask[1] = serialPort[0]->parseInt(); mask[2] = serialPort[0]->parseInt(); mask[3] = serialPort[0]->parseInt(); INFO("Netmask: %d.%d.%d.%d", mask[0], mask[1], mask[2], mask[3]); end: clearSerialRxData(); return; }
bool AtDrv::getTcpAuto(uint8_t sock, bool *enable, long timeout) { bool ret = false; char tcpAutoBuf[MAX_TEMP_BUF_SIZE]; sprintf(tcpAutoBuf, at_tcp_auto[sock], '?'); clearSerialRxData(); INFO1(tcpAutoBuf); serialPort[0]->print(tcpAutoBuf); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->find(tcpAutoBuf)) { INFO1("Fail to get tcp auto"); goto end; } *enable = serialPort[0]->parseInt(); INFO("tcp auto: %d", *enable); clearSerialRxData(); ret = true; end: return ret; }
/* only called for native icecast source clients */ static void _handle_source_request (client_t *client, const char *uri) { INFO1("Source logging in at mountpoint \"%s\"", uri); if (uri[0] != '/') { WARN0 ("source mountpoint not starting with /"); client_send_401 (client); return; } switch (client_check_source_auth (client, uri)) { case 0: /* authenticated from config file */ source_startup (client, uri, ICECAST_SOURCE_AUTH); break; case 1: /* auth pending */ break; default: /* failed */ INFO1("Source (%s) attempted to login with invalid or missing password", uri); client_send_401(client); break; } }
uint8_t AtDrv::getCurrentEncryptionType(long timeout) { uint8_t enc = 0; int bytes; char buf[MAX_TEMP_BUF_SIZE]; if(!isAtMode()) { if(!switchToAtMode()) { INFO1("Can't switch to at mode"); goto end; } } clearSerialRxData(); INFO1(at_get_enc); serialPort[0]->print(at_get_enc); serialPort[0]->print("\r\r"); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); // skip cmd response if(!serialPort[0]->find(at_get_enc)) { INFO1("fail to get enc type"); goto end; } bytes = serialPort[0]->readBytesUntil('\n', buf, MAX_TEMP_BUF_SIZE); if(bytes >= MAX_TEMP_BUF_SIZE) { INFO1("Buffer is not enough"); goto end; } buf[bytes] = NULL; if(strstr(buf, "/TKIPAES") != NULL) { enc = ENC_TYPE_AUTO; } else if(strstr(buf, "NONE") != NULL) { enc = ENC_TYPE_NONE; } else if(strstr(buf, "/AES") != NULL) { enc = ENC_TYPE_CCMP; } else if(strstr(buf, "/TKIP") != NULL) { enc = ENC_TYPE_TKIP; } else if(strstr(buf, "WEP") != NULL) { enc = ENC_TYPE_WEP; } else { INFO1("Unknow, treat as error"); } end: clearSerialRxData(); return enc; }
static void _handle_source_request (client_t *client, char *uri, int auth_style) { source_t *source; INFO1("Source logging in at mountpoint \"%s\"", uri); if (uri[0] != '/') { WARN0 ("source mountpoint not starting with /"); client_send_401 (client); return; } if (auth_style == ICECAST_SOURCE_AUTH) { if (connection_check_source_pass (client->parser, uri) == 0) { /* We commonly get this if the source client is using the wrong * protocol: attempt to diagnose this and return an error */ /* TODO: Do what the above comment says */ INFO1("Source (%s) attempted to login with invalid or missing password", uri); client_send_401(client); return; } } source = source_reserve (uri); if (source) { if (auth_style == SHOUTCAST_SOURCE_AUTH) { source->shoutcast_compat = 1; } source->client = client; source->parser = client->parser; source->con = client->con; if (connection_complete_source (source, 1) < 0) { source_clear_source (source); source_free_source (source); } else { refbuf_t *ok = refbuf_new (PER_CLIENT_REFBUF_SIZE); client->respcode = 200; snprintf (ok->data, PER_CLIENT_REFBUF_SIZE, "HTTP/1.0 200 OK\r\n\r\n"); ok->len = strlen (ok->data); /* we may have unprocessed data read in, so don't overwrite it */ ok->associated = client->refbuf; client->refbuf = ok; fserve_add_client_callback (client, source_client_callback, source); } } else { client_send_404 (client, "Mountpoint in use"); WARN1 ("Mountpoint %s in use", uri); } }
bool AtDrv::getProtocol(uint8_t sock, uint8_t *protocol, long timeout) { bool ret = false; int bytes; char protModeBuf[MAX_TEMP_BUF_SIZE]; sprintf(protModeBuf, at_remotepro[sock], "?"); clearSerialRxData(); INFO1(protModeBuf); serialPort[0]->print(protModeBuf); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->find(protModeBuf)) { INFO1("Fail to get protocol"); goto end; } bytes = serialPort[0]->readBytes(protModeBuf, MAX_TEMP_BUF_SIZE); if(bytes >= MAX_TEMP_BUF_SIZE) { INFO1("Buffer is not enough"); goto end; } protModeBuf[bytes] = NULL; if(sock == 0) { if(strstr(protModeBuf, "tcp")) { *protocol = PROTO_MODE_TCP; ret = true; } else if(strstr(protModeBuf, "udp")) { *protocol = PROTO_MODE_UDP; ret = true; } } else { if(strstr(protModeBuf, "1")) { *protocol = PROTO_MODE_TCP; ret = true; } else if(strstr(protModeBuf, "2")) { *protocol = PROTO_MODE_UDP; ret = true; } } end: return ret; }
bool AtDrv::getMode(uint8_t sock, int *mode, long timeout) { bool ret = false; int bytes; char modeBuf[MAX_TEMP_BUF_SIZE]; sprintf(modeBuf, at_mode[sock], "?"); clearSerialRxData(); INFO1(modeBuf); serialPort[0]->print(modeBuf); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); if(!serialPort[0]->find(modeBuf)) { INFO1("Fail to get mode"); goto end; } bytes = serialPort[0]->readBytes(modeBuf, MAX_TEMP_BUF_SIZE); if(bytes >= MAX_TEMP_BUF_SIZE) { INFO1("Buffer is not enough"); goto end; } modeBuf[bytes] = NULL; if(sock == 0) { if(strstr(modeBuf, "server")) { *mode = MODE_SERVER; ret = true; } else if(strstr(modeBuf, "client")) { *mode = MODE_CLIENT; ret = true; } } else { if(strstr(modeBuf, "1")) { *mode = MODE_SERVER; ret = true; } else if(strstr(modeBuf, "2")) { *mode = MODE_CLIENT; ret = true; } } end: return ret; }
uint16_t AtDrv::readBytes(uint8_t sock, uint8_t *_data, uint16_t *_dataLen) { uint16_t len = 0; // sock1 (second uart port) is always in data mode, so don't need to switch mode if(sock == 0 && isAtMode()) { if(!switchToDataMode()) { INFO1("Can't switch to data mode"); goto end; } } // if sock0 && sock0DataQueue has data, then read data in sock0DataQueue first if(sock == 0) { while(!sock0DataQueue.isEmpty()) { _data[len++] = sock0DataQueue.pop(); // full? then exit if(len == *_dataLen) goto end; } // substrate data length we've filled *_dataLen -= len; } len += serialPort[sock]->readBytes((char *)_data+len, *_dataLen); *_dataLen = len; end: return len; }
/* wrapper function for auth thread to authenticate new listener * connection details */ static void auth_new_listener (auth_t *auth, auth_client *auth_user) { client_t *client = auth_user->client; /* make sure there is still a client at this point, a slow backend request * can be avoided if client has disconnected */ if (is_listener_connected (client) == 0) { DEBUG0 ("listener is no longer connected"); client->respcode = 400; auth_release (client->auth); client->auth = NULL; return; } if (auth->authenticate) { if (auth->authenticate (auth_user) != AUTH_OK) { auth_release (client->auth); client->auth = NULL; return; } } if (auth_postprocess_listener (auth_user) < 0) { auth_release (client->auth); client->auth = NULL; INFO1 ("client %lu failed", client->con->id); } }
bool AtDrv::echoTest(long timeout) { char buf[MAX_TEMP_BUF_SIZE+1]; int i; char *token; clearSerialRxData(); serialPort[0]->println("#32767"); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); i = serialPort[0]->readBytes(buf, MAX_TEMP_BUF_SIZE); if(i == 0) { INFO1("Echo No resp"); return false; } buf[i] = NULL; token = buf; while(*token && *token++ != '#'); int ret = strtol(token, NULL, 10); clearSerialRxData(); return (ret == 32767)? true:false; }
void _sig_die(int signo) { INFO1("Caught signal %d, shutting down...", signo); /* inform the server to start shutting down */ global.running = ICE_HALTING; }
static void _handle_source_request(connection_t *con, http_parser_t *parser, char *uri) { client_t *client; source_t *source; client = client_create(con, parser); INFO1("Source logging in at mountpoint \"%s\"", uri); if (uri[0] != '/') { WARN0 ("source mountpoint not starting with /"); client_send_401 (client); return; } if (!connection_check_source_pass(parser, uri)) { /* We commonly get this if the source client is using the wrong * protocol: attempt to diagnose this and return an error */ /* TODO: Do what the above comment says */ INFO1("Source (%s) attempted to login with invalid or missing password", uri); client_send_401(client); return; } source = source_reserve (uri); if (source) { source->client = client; source->parser = parser; source->con = con; if (connection_complete_source (source) < 0) { source->client = NULL; source_free_source (source); } else thread_create ("Source Thread", source_client_thread, source, THREAD_DETACHED); } else { client_send_404 (client, "Mountpoint in use"); WARN1 ("Mountpoint %s in use", uri); } }
static void get_ssl_certificate (ice_config_t *config) { ssl_ok = 0; do { long ssl_opts; ssl_ctx = NULL; if (config->cert_file == NULL) break; ssl_ctx = SSL_CTX_new (SSLv23_server_method()); ssl_opts = SSL_CTX_get_options (ssl_ctx); SSL_CTX_set_options (ssl_ctx, ssl_opts|SSL_OP_NO_SSLv2); if (SSL_CTX_use_certificate_chain_file (ssl_ctx, config->cert_file) <= 0) { WARN1 ("Invalid cert file %s", config->cert_file); break; } if (SSL_CTX_use_PrivateKey_file (ssl_ctx, config->cert_file, SSL_FILETYPE_PEM) <= 0) { WARN1 ("Invalid private key file %s", config->cert_file); break; } if (!SSL_CTX_check_private_key (ssl_ctx)) { ERROR1 ("Invalid %s - Private key does not match cert public key", config->cert_file); break; } if (SSL_CTX_set_cipher_list(ssl_ctx, config->cipher_list) <= 0) { WARN1 ("Invalid cipher list: %s", config->cipher_list); } ssl_ok = 1; INFO1 ("SSL certificate found at %s", config->cert_file); INFO1 ("SSL using ciphers %s", config->cipher_list); return; } while (0); if (ssl_ctx) { WARN2 ("failed to load cert %s (%s)", config->cert_file, ERR_reason_error_string (ERR_peek_last_error())); SSL_CTX_free (ssl_ctx); ssl_ctx = NULL; } INFO0 ("No SSL capability on any configured ports"); }
void AtDrv::netCommit() { clearSerialRxData(); INFO1(at_net_commit); serialPort[0]->print(at_net_commit); serialPort[0]->flush(); delay(30000); // No any response }
static void get_ssl_certificate (ice_config_t *config) { SSL_METHOD *method; long ssl_opts; ssl_ok = 0; SSL_load_error_strings(); /* readable error messages */ SSL_library_init(); /* initialize library */ method = SSLv23_server_method(); ssl_ctx = SSL_CTX_new (method); ssl_opts = SSL_CTX_get_options (ssl_ctx); SSL_CTX_set_options (ssl_ctx, ssl_opts|SSL_OP_NO_SSLv2); do { if (config->cert_file == NULL) break; if (SSL_CTX_use_certificate_chain_file (ssl_ctx, config->cert_file) <= 0) { WARN1 ("Invalid cert file %s", config->cert_file); break; } if (SSL_CTX_use_PrivateKey_file (ssl_ctx, config->cert_file, SSL_FILETYPE_PEM) <= 0) { WARN1 ("Invalid private key file %s", config->cert_file); break; } if (!SSL_CTX_check_private_key (ssl_ctx)) { ERROR1 ("Invalid %s - Private key does not match cert public key", config->cert_file); break; } if (SSL_CTX_set_cipher_list(ssl_ctx, config->cipher_list) <= 0) { WARN1 ("Invalid cipher list: %s", config->cipher_list); } ssl_ok = 1; INFO1 ("SSL certificate found at %s", config->cert_file); INFO1 ("SSL using ciphers %s", config->cipher_list); return; } while (0); INFO0 ("No SSL capability on any configured ports"); }
/*! \fn printVector * * \param [in] [vector] * \param [in] [size] * \param [in] [logLevel] * \param [in] [name] * * \author wbraun */ static void printVector(const double *vector, integer *size, const int logLevel, const char *name) { int i; INFO1(logLevel, "%s", name); INDENT(logLevel); for(i=0; i<*size; i++) INFO2(logLevel, "[%d] %10g", i, vector[i]); RELEASE(logLevel); }
void AtDrv::getGateway(uint8_t *gwip, long timeout) { int bytes; int start; char lineBuf[MAX_LINE_BUF_SIZE]; char *token; clearSerialRxData(); INFO1(at_get_gateway); serialPort[0]->print(at_get_gateway); serialPort[0]->print("\r\r"); serialPort[0]->flush(); serialPort[0]->setTimeout(timeout); // skip cmd response && skip until "00000000" if(!serialPort[0]->find(at_get_gateway) || !serialPort[0]->find("00000000")) { INFO1("fail to get gateway"); gwip[0] = gwip[1] = gwip[2] = gwip[3] = 0; goto end; } bytes = serialPort[0]->readBytesUntil('\n', lineBuf, MAX_LINE_BUF_SIZE); if(bytes >= MAX_LINE_BUF_SIZE) { INFO1("Buffer is not enough"); goto end; } token = strtok(lineBuf, " \t"); if(token) *((uint32_t *)gwip) = strtol(token, NULL, 16); else { INFO1("fail to parse netmask"); gwip[0] = gwip[1] = gwip[2] = gwip[3] = 0; goto end; } INFO("Gateway: %d.%d.%d.%d", gwip[0], gwip[1], gwip[2], gwip[3]); end: clearSerialRxData(); return; }
void workers_adjust (int new_count) { INFO1 ("requested worker count %d", new_count); while (worker_count != new_count) { if (worker_count < new_count) worker_start (); else if (worker_count > new_count) worker_stop (); } }
FDWEpollBackend::FDWEpollBackend(int nfds_) :FDWBackend(nfds_), sr(0) { if ((epfd = epoll_create(nfds)) < 0) throw InitError("failed to open epoll device"); epevents.reset(new struct epoll_event[nfds]); std::memset(epevents.get(), 0, sizeof(struct epoll_event) * nfds); INFO1("fdwatch epoll() based layer initialized (max %d sockets)", nfds); }
static int admin_handle_general_request (client_t *client, const char *uri) { struct admin_command *cmd; if ((client->flags & CLIENT_AUTHENTICATED) == 0) { INFO1("Bad or missing password on admin command request (%s)", uri); return client_send_401 (client, NULL); } cmd = find_admin_command (admin_general, uri); if (cmd == NULL) { INFO1 ("processing file %s", uri); return command_stats (client, uri); } if (cmd->handle.general == NULL) return client_send_400 (client, "unknown request"); return cmd->handle.general (client, cmd->response); }