void cg_upnp_property_clear(CgUpnpProperty *prop)
{
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(prop->name, NULL);
cg_string_setvalue(prop->value, NULL);
cg_string_setvalue(prop->sid, NULL);
cg_log_debug_l4("Leaving...\n");
}
CgNetURI *cg_net_uri_new()
{
CgNetURI *uri;
cg_log_debug_l4("Entering...\n");
uri = (CgNetURI *)malloc(sizeof(CgNetURI));
if (NULL != uri)
{
uri->uri = cg_string_new();
uri->protocol = cg_string_new();
uri->user = cg_string_new();
uri->password = cg_string_new();
uri->host = cg_string_new();
uri->port = 0;
uri->path = cg_string_new();
uri->query = cg_string_new();
uri->fragment = cg_string_new();
uri->request = NULL;
uri->queryDictionary = NULL;
/**** Thanks for Theo Beisch (2005/08/25) ****/
cg_string_setvalue(uri->path, CG_NET_URI_DEFAULT_PATH);
}
cg_log_debug_l4("Leaving...\n");
return uri;
}
void cg_net_uri_rebuild(CgNetURI *uri)
{
char portStr[32];
char *path;
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(uri->uri, cg_net_uri_getprotocol(uri));
cg_string_addvalue(uri->uri, CG_NET_URI_PROTOCOL_DELIM);
cg_string_addvalue(uri->uri, cg_net_uri_gethost(uri));
cg_string_addvalue(uri->uri, CG_NET_URI_COLON_DELIM);
cg_string_addvalue(uri->uri, cg_int2str(cg_net_uri_getport(uri), portStr, sizeof(portStr)));
if (0 < cg_strlen(cg_net_uri_getpath(uri))) {
path = cg_net_uri_getpath(uri);
if (path[0] != '/')
cg_string_addvalue(uri->uri, CG_NET_URI_SLASH_DELIM);
cg_string_addvalue(uri->uri, cg_net_uri_getpath(uri));
if (cg_strchr(cg_net_uri_getpath(uri), "?", 1) == -1 && 0 < cg_strlen(cg_net_uri_getquery(uri))) {
cg_string_addvalue(uri->uri, CG_NET_URI_QUESTION_DELIM);
cg_string_addvalue(uri->uri, cg_net_uri_getquery(uri));
}
}
cg_log_debug_l4("Leaving...\n");
}
BOOL cg_socket_joingroup(CgSocket *sock, char *mcastAddr, char *ifAddr)
{
struct ip_mreq ipmr;
u_long ifInetAddr = ka_inet_addr(ifAddr);
BOOL joinSuccess;
int sockOptRetCode;
cg_log_debug_l4("Entering...\n");
joinSuccess = TRUE;
ka_inet_pton( AF_INET, mcastAddr, &(ipmr.imr_multiaddr) );
memcpy(&ipmr.imr_interface, &ifInetAddr, sizeof(struct in_addr));
sockOptRetCode = ka_setsockopt(sock->id, IP_PROTOIP, IPO_ADD_MEMBERSHIP, (char *)&ipmr, sizeof(ipmr));
if (sockOptRetCode != 0)
joinSuccess = FALSE;
cg_string_setvalue(sock->ipaddr, (joinSuccess == TRUE) ? ifAddr : NULL);
cg_log_debug_l4("Leaving...\n");
return joinSuccess;
}
const char *cg_upnp_event_subscription_totimeoutheaderstring(CgTime time, CgString *buf)
{
char timeBuf[CG_STRING_LONG_BUFLEN];
cg_log_debug_l4("Entering...\n");
if (time != CG_UPNP_SUBSCRIPTION_INFINITE_VALUE) {
cg_string_setvalue(buf, CG_UPNP_SUBSCRIPTION_TIMEOUT_HEADER);
cg_string_addvalue(buf, cg_long2str(time, timeBuf, sizeof(timeBuf)));
}
else
cg_string_setvalue(buf, CG_UPNP_SUBSCRIPTION_INFINITE_STRING);
return cg_string_getvalue(buf);
cg_log_debug_l4("Leaving...\n");
}
char *cg_string_replace(CgString *str, char *fromStr[], char *toStr[], size_t fromStrCnt)
{
char *orgValue = NULL;
size_t orgValueLen = 0;
int n = 0;
int copyPos = 0;
size_t *fromStrLen = NULL;
CgString *repValue = NULL;
BOOL isReplaced = FALSE;
cg_log_debug_l5("Entering...\n");
if (NULL == str )
return NULL;
repValue = cg_string_new();
fromStrLen = (size_t *)malloc(sizeof(size_t) * fromStrCnt);
if ( NULL == fromStrLen )
{
cg_string_delete(repValue);
cg_log_debug_s("Memory allocation failure!\n");
return NULL;
}
for (n=0; n<fromStrCnt; n++)
fromStrLen[n] = cg_strlen(fromStr[n]);
orgValue = cg_string_getvalue(str);
orgValueLen = cg_string_length(str);
copyPos = 0;
while (copyPos<orgValueLen) {
isReplaced = FALSE;
for (n=0; n<fromStrCnt; n++) {
if (strncmp(fromStr[n], orgValue + copyPos, fromStrLen[n]) == 0) {
cg_string_addvalue(repValue, toStr[n]);
copyPos += fromStrLen[n];
isReplaced = TRUE;
continue;
}
}
if (isReplaced == TRUE)
continue;
cg_string_naddvalue(repValue, orgValue + copyPos, 1);
copyPos++;
}
free(fromStrLen);
cg_string_setvalue(str, cg_string_getvalue(repValue));
cg_string_delete(repValue);
cg_log_debug_l5("Leaving...\n");
return cg_string_getvalue(str);
}
void cg_http_request_seturi(CgHttpRequest *httpReq, char *value)
{
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(httpReq->uri, value);
cg_log_debug_l4("Leaving...\n");
}
void cg_net_interface_setnetmask(CgNetworkInterface *netIf, char *value)
{
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(netIf->netmask, value);
cg_log_debug_l4("Leaving...\n");
}
void cg_net_interface_setaddress(CgNetworkInterface *netIf, char *value)
{
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(netIf->ipaddr, value);
cg_log_debug_l4("Leaving...\n");
}
void cg_net_interface_setname(CgNetworkInterface *netIf, char *name)
{
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(netIf->name, name);
cg_log_debug_l4("Leaving...\n");
}
void cg_http_header_setvalue(CgHttpHeader *header, const char *value)
{
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(header->value, value);
cg_log_debug_l4("Leaving...\n");
}
void cg_upnpav_resource_setdlnaattribute(CgUpnpAvResource *res, char *attr)
{
CgUpnpAvResourceData *nodeData;
nodeData = (CgUpnpAvResourceData *)cg_xml_node_getuserdata(res);
cg_string_setvalue(nodeData->dlnaAttr, attr);
cg_upnpav_resource_updateattributes(res);
}
void cg_upnpav_resource_setmimetype(CgUpnpAvResource *res, char *mimeType)
{
CgUpnpAvResourceData *nodeData;
nodeData = (CgUpnpAvResourceData *)cg_xml_node_getuserdata(res);
cg_string_setvalue(nodeData->mimeType, mimeType);
cg_upnpav_resource_updateattributes(res);
}
void cg_http_packet_clear(CgHttpPacket *httpPkt)
{
cg_log_debug_l4("Entering...\n");
cg_http_headerlist_clear(httpPkt->headerList);
cg_string_setvalue(httpPkt->content, NULL);
cg_log_debug_l4("Leaving...\n");
}
void cg_string_setlongvalue(CgString *str, long value)
{
char buf[CG_STRING_LONG_BUFLEN];
cg_log_debug_l5("Entering...\n");
cg_string_setvalue(str, cg_long2str(value, buf, sizeof(buf)));
cg_log_debug_l5("Leaving...\n");
}
void cg_string_setintvalue(CgString *str, int value)
{
char buf[CG_STRING_INTEGER_BUFLEN];
cg_log_debug_l5("Entering...\n");
cg_string_setvalue(str, cg_int2str(value, buf, sizeof(buf)));
cg_log_debug_l5("Leaving...\n");
}
char *cg_net_uri_getrequest(CgNetURI *uri)
{
cg_log_debug_l4("Entering...\n");
if (cg_net_uri_hasquery(uri) == FALSE)
{
return cg_net_uri_getpath(uri);
}
if (uri->request == NULL) uri->request = cg_string_new();
cg_string_setvalue(uri->request, cg_net_uri_getpath(uri));
cg_string_addvalue(uri->request, CG_NET_URI_QUESTION_DELIM);
cg_string_addvalue(uri->request, cg_net_uri_getquery(uri));
cg_log_debug_l4("Leaving...\n");
return cg_string_getvalue(uri->request);
}
static char *cg_xml_node_attribute_tostring(CgXmlNode *node, CgString *str)
{
CgXmlAttribute *attr;
char *name;
char *value;
CgString *valueStr;
cg_log_debug_l4("Entering...\n");
valueStr = cg_string_new();
if (valueStr == NULL) return NULL;
for (attr = cg_xml_node_getattributes(node); attr != NULL; attr = cg_xml_attribute_next(attr)) {
name = cg_xml_attribute_getname(attr);
value = cg_xml_attribute_getvalue(attr);
cg_string_setvalue(valueStr, value);
cg_xml_escapechars(valueStr);
/* All the following functions return NULL only when memory
allocation fails, so we can check them all */
if (!cg_string_naddvalue(str, " ", 1) ||
!cg_string_addvalue(str, name) ||
!cg_string_naddvalue(str, "=\"", 2) ||
!cg_string_addvalue(str, cg_string_getvalue(valueStr)) ||
!cg_string_naddvalue(str, "\"", 1))
{
/* Memory allocation failed */
cg_string_delete(valueStr);
return NULL;
}
}
cg_string_delete(valueStr);
cg_log_debug_l4("Leaving...\n");
return cg_string_getvalue(str);
}
static void cg_upnp_statevariable_setvaluewithnotify(CgUpnpStateVariable *statVar, char *data, BOOL doNotify)
{
CgUpnpService *service;
cg_log_debug_l4("Entering...\n");
cg_string_setvalue(statVar->value, data);
#if !defined(CG_UPNP_NOUSE_SUBSCRIPTION)
/**** notify event ****/
if (doNotify) {
if (cg_upnp_statevariable_issendevents(statVar) == FALSE)
return;
service = cg_upnp_statevariable_getservice(statVar);
if (service == NULL)
return;
cg_upnp_service_notify(service, statVar);
}
#endif
cg_log_debug_l4("Leaving...\n");
}
BOOL cg_http_persistentconnection_put(char *host, int port, void *data)
{
CgHttpPersistentConnection *new_node = NULL, *node = NULL;
cg_log_debug_l4("Entering...\n");
/* If we dont have cache, then just exit */
if (cache == NULL) {
cg_log_debug("(put) No cache! Persistent connections not initialized?\n");
return FALSE;
}
/* Check if we already have this one cached */
for (node = (CgHttpPersistentConnection*)cg_list_gets((CgList*)cache);
node != NULL;
node = (CgHttpPersistentConnection*)cg_list_next((CgList*)node))
{
if (cg_strcmp(cg_string_getvalue(node->host), host) == 0 &&
node->port == port)
{
/* If also data is the same, then update just
timestamp */
if (node->cacheData == data)
{
node->timestamp = cg_getcurrentsystemtime();
return TRUE;
}
cg_log_debug_s("Found cached persistent connection for %s:%d\n",
cg_string_getvalue(node->host), node->port);
new_node = node;
cg_list_remove((CgList*)new_node);
break;
}
}
/* We didn't find it */
if (new_node == NULL)
{
/* Check if we have already too many cached things */
if (cg_list_size((CgList*)cache) >= CG_HTTP_PERSISTENT_CACHE_SIZE)
{
/* Take last node (not refreshed for a long time) */
new_node = (CgHttpPersistentConnection *)cg_list_next((CgList *)cache);
cg_list_remove((CgList*)new_node);
cg_http_persistentconnection_delete(new_node);
new_node = NULL;
cg_log_debug_s("Max persistent HTTP connection cache reached.\n");
}
if (new_node == NULL)
{
if (data == NULL) return TRUE;
new_node = cg_http_persistentconnection_new();
if (new_node == NULL) return FALSE;
cg_log_debug_s("Adding persistent HTTP Connection %s:%d to cache\n",
host, port);
cg_log_debug_s("Persistent connections: %d\n", cg_list_size((CgList*)cache));
}
}
if (data != NULL)
{
/* Set appropriate values for the node */
cg_string_setvalue(new_node->host, host);
new_node->port = port;
new_node->cacheData = data;
new_node->timestamp = cg_getcurrentsystemtime();
cg_list_add((CgList*)cache, (CgList*)new_node);
} else {
/* remove and delete node */
cg_http_persistentconnection_delete(new_node);
}
return TRUE;
cg_log_debug_l4("Leaving...\n");
}
void cg_upnpav_resource_data_copy(CgUpnpAvResourceData* destResData, CgUpnpAvResourceData* srcResData)
{
cg_string_setvalue(destResData->mimeType, cg_string_getvalue(srcResData->mimeType));
}
static char *cg_xml_node_tostring_indent(CgXmlNode *node, int indentLevel, BOOL withChildNode, CgString *str)
{
char *name;
char *value;
CgString *valueStr;
CgXmlNode *childNode;
cg_log_debug_l4("Entering...\n");
name = cg_xml_node_getname(node);
value = cg_xml_node_getvalue(node);
if (cg_xml_node_haschildnodes(node) == FALSE || withChildNode == FALSE) {
cg_string_addrepvalue(str, CG_XML_INDENT_STRING, indentLevel);
if (!cg_string_naddvalue(str, "<", 1) ||
!cg_string_addvalue(str, name) ||
!cg_xml_node_attribute_tostring(node, str))
/* Memory allocation failed */
return NULL;
valueStr = cg_string_new();
if (!valueStr)
/* Memory allocation failed */
return NULL;
cg_string_setvalue(valueStr, value);
cg_xml_escapechars(valueStr);
if (!cg_string_naddvalue(str, ">", 1) ||
!cg_string_addvalue(str, cg_string_getvalue(valueStr)) ||
!cg_string_naddvalue(str, "</", 2) ||
!cg_string_addvalue(str, name) ||
!cg_string_naddvalue(str, ">", 1) ||
!cg_string_addvalue(str, "\n"))
{
/* Memory allocation failed */
cg_string_delete(valueStr);
return NULL;
}
cg_string_delete(valueStr);
return cg_string_getvalue(str);
}
cg_string_addrepvalue(str, CG_XML_INDENT_STRING, indentLevel);
if (!cg_string_naddvalue(str, "<", 1) ||
!cg_string_addvalue(str, name) ||
!cg_xml_node_attribute_tostring(node, str) ||
!cg_string_naddvalue(str, ">", 1) ||
!cg_string_addvalue(str, "\n"))
/* Memory allocation failed */
return NULL;
for (childNode = cg_xml_node_getchildnodes(node); childNode != NULL; childNode = cg_xml_node_next(childNode))
if (!cg_xml_node_tostring_indent(childNode, indentLevel+1, TRUE, str))
/* Memory allocation failed */
return NULL;
cg_string_addrepvalue(str, CG_XML_INDENT_STRING, indentLevel);
if (!cg_string_naddvalue(str, "</", 2) ||
!cg_string_addvalue(str, name) ||
!cg_string_naddvalue(str, ">", 1) ||
!cg_string_addvalue(str, "\n"))
/* Memory allocation failed */
return NULL;
cg_log_debug_l4("Leaving...\n");
return cg_string_getvalue(str);
}
CgHttpResponse *cg_http_request_post(CgHttpRequest *httpReq, char *ipaddr, int port)
{
CgHttpResponse *httpRes;
BOOL newCurl = FALSE;
CURL *curl;
CgHttpHeader *reqHeader;
struct curl_slist *curlHeaderList;
CgString *headerStr;
CURLcode res;
char *uri, *method;
char url[CG_NET_URI_MAXLEN];
long retcode;
#ifdef CG_SHOW_TIMINGS
struct timeval start_time, end_time, elapsed_time;
#endif
cg_log_debug_l4("Entering...\n");
#ifdef CG_SHOW_TIMINGS
gettimeofday(&start_time, NULL);
#endif
httpRes = httpReq->httpRes;
/* Clear the response data because new data will not
* overwrite it, but it is appended to the end */
cg_string_clear(httpRes->content);
cg_log_debug_s("Posting HTTP request (Curl)\n");
cg_http_request_print(httpReq);
cg_http_persistentconnection_lock();
#ifdef CG_HTTP_USE_PERSISTENT_CONNECTIONS
cg_log_debug_s("Looking for persistent connection to %s, port %d\n", ipaddr, port);
curl = (CURL*)cg_http_persistentconnection_get(ipaddr, port);
if (curl == NULL)
{
cg_log_debug_s("Persistent connection not found...\n");
#endif
curl = curl_easy_init();
if (curl == NULL)
{
cg_http_persistentconnection_unlock();
return httpReq->httpRes;
}
#ifdef CG_HTTP_USE_PERSISTENT_CONNECTIONS
newCurl = TRUE;
}
#endif
method = cg_http_request_getmethod(httpReq);
uri = cg_http_request_geturi(httpReq);
/**** method ****/
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method);
/**** url ****/
if (uri && cg_strstr(uri, CG_NET_URI_PROTOCOL_DELIM) > 0)
{
curl_easy_setopt(curl, CURLOPT_URL, uri);
}
else
{
cg_net_gethosturl(ipaddr, port, uri, url, sizeof(url));
curl_easy_setopt(curl, CURLOPT_URL, url);
cg_log_debug_s("\n\nCURL: %s\n\n", url);
}
/**** header ****/
curlHeaderList = NULL;
headerStr = cg_string_new();
for (reqHeader = cg_http_request_getheaders(httpReq); reqHeader; reqHeader = cg_http_header_next(reqHeader)) {
cg_string_setvalue(headerStr, cg_http_header_getname(reqHeader));
if (cg_string_addvalue(headerStr, CG_HTTP_COLON CG_HTTP_SP) &&
cg_string_addvalue(headerStr, cg_http_header_getvalue(reqHeader)))
curlHeaderList = curl_slist_append(curlHeaderList, cg_string_getvalue(headerStr));
}
cg_string_delete(headerStr);
/* Disable Expect header because it causes IOP issues */
curlHeaderList = curl_slist_append(curlHeaderList, "Expect:");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curlHeaderList);
/**** content ****/
/*if (cg_http_request_ispostrequest(httpReq) == TRUE) {*/
if (cg_http_request_getcontentlength(httpReq) > 0) {
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, cg_http_request_getcontent(httpReq));
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, cg_http_request_getcontentlength(httpReq));
}
else
{
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
}
/* This has to be enabled for progress callback to be called */
curl_easy_setopt(curl, CURLOPT_NOPROGRESS,
FALSE);
/* Used for checking stack state during curl easy perform */
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION,
cg_http_request_progress_callback);
/**** response header callback ****/
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION,
cg_http_request_header_callback);
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)httpRes);
/**** response content callback ****/
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
cg_http_request_content_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)httpRes);
/**** useragent ****/
curl_easy_setopt(curl, CURLOPT_USERAGENT, cg_http_request_getuseragent(httpReq) );
/**** Prohibit curl from using signals ****/
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
/**** Set the connection timeout so we don't wait forever ****/
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT,
CG_HTTP_CURL_CONNECTTIMEOUT);
curl_easy_setopt(curl, CURLOPT_TIMEOUT,
CG_HTTP_CONN_TIMEOUT);
#ifdef CG_SHOW_TIMINGS
cg_log_debug_s("\nRequest: %s%s%s\n", method, CG_HTTP_SP, url);
#endif
/* Get the XML document with CURL */
res = curl_easy_perform(curl);
if (res != CURLE_OK)
cg_log_debug_s("curl_easy_perform: %s\n",
curl_easy_strerror(res));
/* Set the content length, if it wasn't said in the header */
if (cg_http_response_getcontentlength(httpRes) <= 0)
{
cg_http_response_setcontentlength(httpRes,
cg_string_length(httpRes->content));
}
curl_slist_free_all(curlHeaderList);
curl_easy_getinfo (curl, CURLINFO_HTTP_CODE, &retcode);
cg_http_response_setstatuscode(httpRes, retcode);
#ifdef CG_SHOW_TIMINGS
gettimeofday(&end_time, NULL);
timersub(&end_time, &start_time, &elapsed_time);
cg_log_debug_s("Getting HTTP-response completed. Elapsed time: "
"%ld msec\n", ((elapsed_time.tv_sec*1000) +
(elapsed_time.tv_usec/1000)));
cg_total_elapsed_time += (elapsed_time.tv_sec*1000000)+
(elapsed_time.tv_usec);
#endif
#ifdef CG_HTTP_USE_PERSISTENT_CONNECTIONS
if (newCurl)
{
cg_log_debug_s("Putting new connection into cache: %s %d\n", ipaddr, port);
cg_http_persistentconnection_put(ipaddr, port, curl);
}
#else
curl_easy_cleanup(curl);
#endif
cg_http_persistentconnection_unlock();
cg_log_debug_s("Response for HTTP request (Curl)\n");
cg_http_response_print(httpReq->httpRes);
return httpReq->httpRes;
cg_log_debug_l4("Leaving...\n");
}
void cg_net_uri_setvalue(CgNetURI *uri, char *value)
{
char *protocol;
int uriLen;
int currIdx;
int protoIdx;
int atIdx;
int colonIdx;
int shashIdx;
char *host;
int eblacketIdx;
CgString *hostStr;
CgString *portStr;
int hostLen;
int sharpIdx;
int questionIdx;
int queryLen;
cg_log_debug_l4("Entering...\n");
uriLen = cg_strlen(value);
cg_net_uri_clear(uri);
cg_net_uri_seturi(uri, value);
currIdx = 0;
/*** Protocol ****/
protoIdx = cg_strstr(value, CG_NET_URI_PROTOCOL_DELIM);
if (0 < protoIdx) {
cg_string_setnvalue(uri->protocol, value, protoIdx);
currIdx += protoIdx + cg_strlen(CG_NET_URI_PROTOCOL_DELIM);
}
/*** User (Password) ****/
atIdx = cg_strstr(value+currIdx, CG_NET_URI_USER_DELIM);
if (0 < atIdx) {
colonIdx = cg_strstr(value+currIdx, CG_NET_URI_COLON_DELIM);
/**** Thanks for Theo Beisch (2005/08/25) ****/
if (0 < colonIdx && colonIdx<atIdx) {
cg_string_setnvalue(uri->user, value+currIdx, colonIdx);
cg_string_setnvalue(uri->password, value+currIdx+colonIdx+1, atIdx-(colonIdx+1));
}
else
cg_string_setnvalue(uri->user, value+currIdx, atIdx - currIdx);
currIdx += atIdx + 1;
}
/*** Host (Port) ****/
shashIdx = cg_strstr(value+currIdx, CG_NET_URI_SLASH_DELIM);
if (0 < shashIdx)
cg_string_setnvalue(uri->host, value+currIdx, shashIdx);
else if (cg_net_uri_isabsolute(uri) == TRUE)
cg_string_setnvalue(uri->host, value+currIdx, cg_strlen(value) - currIdx);
host = cg_net_uri_gethost(uri);
colonIdx = cg_strrchr(host, CG_NET_URI_COLON_DELIM, 1);
eblacketIdx = cg_strrchr(host, CG_NET_URI_EBLACET_DELIM, 1);
if (0 < colonIdx && eblacketIdx < colonIdx) {
hostStr = cg_string_new();
cg_string_setvalue(hostStr, host);
hostLen = cg_string_length(hostStr);
/**** host ****/
cg_string_setnvalue(uri->host, cg_string_getvalue(hostStr), colonIdx);
host = cg_net_uri_gethost(uri);
if (0 < hostLen) {
if (host[0] == '[' && host[hostLen-1] == ']')
cg_string_setnvalue(uri->host, cg_string_getvalue(hostStr)+1, colonIdx-2);
}
/**** port ****/
portStr = cg_string_new();
cg_string_setnvalue(portStr, cg_string_getvalue(hostStr)+colonIdx+1, hostLen- colonIdx-1);
uri->port = atoi(cg_string_getvalue(portStr));
cg_string_delete(portStr);
cg_string_delete(hostStr);
}
else {
uri->port = CG_NET_URI_KNKOWN_PORT;
protocol = cg_net_uri_getprotocol(uri);
if (cg_strcmp(protocol, CG_NET_URI_PROTOCOL_HTTP) == 0)
uri->port = CG_NET_URI_DEFAULT_HTTP_PORT;
if (cg_strcmp(protocol, CG_NET_URI_PROTOCOL_FTP) == 0)
uri->port = CG_NET_URI_DEFAULT_FTP_PORT;
}
if (shashIdx > 0) currIdx += shashIdx;
/*
Handle relative URL
*/
if (cg_net_uri_isabsolute(uri) == FALSE)
{
cg_string_addvalue(uri->path, value);
} else {
/* First set path simply to the rest of URI */
cg_string_setnvalue(uri->path, value+currIdx, uriLen-currIdx);
}
/**** Path (Query/Fragment) ****/
sharpIdx = cg_strstr(value+currIdx, CG_NET_URI_SHARP_DELIM);
if (0 < sharpIdx) {
cg_string_setnvalue(uri->path, value+currIdx, sharpIdx);
cg_string_setnvalue(uri->fragment, value+currIdx+sharpIdx+1, uriLen-(currIdx+sharpIdx+1));
}
questionIdx = cg_strstr(value+currIdx, CG_NET_URI_QUESTION_DELIM);
if (0 < questionIdx) {
cg_string_setnvalue(uri->path, value+currIdx, questionIdx);
queryLen = uriLen-(currIdx+questionIdx+1);
if (0 < sharpIdx)
queryLen -= uriLen - (currIdx+sharpIdx);
cg_string_setnvalue(uri->query, value+currIdx+questionIdx+1, queryLen);
}
cg_log_debug_l4("Leaving...\n");
}
