CgHttpRequest *cg_http_request_new()
{
CgHttpRequest *httpReq;
cg_log_debug_l4("Entering...\n");
httpReq = (CgHttpRequest *)malloc(sizeof(CgHttpRequest));
if ( NULL != httpReq )
{
cg_http_packet_init((CgHttpPacket *)httpReq);
httpReq->method = cg_string_new();
httpReq->version = cg_string_new();
httpReq->uri = cg_string_new();
httpReq->userAgent = cg_string_new();
httpReq->httpRes = cg_http_response_new();
httpReq->postURL = cg_net_url_new();
cg_http_request_setversion(httpReq, CG_HTTP_VER11);
cg_http_request_setuseragent(httpReq, CG_HTTP_USERAGENT_DEFAULT);
cg_http_request_setsocket(httpReq, NULL);
cg_http_request_setuserdata(httpReq, NULL);
cg_http_request_settimeout(httpReq, CG_HTTP_CONN_TIMEOUT);
}
cg_log_debug_l4("Leaving...\n");
return httpReq;
}
CgXmlNode *cg_xml_node_new()
{
CgXmlNode *node;
cg_log_debug_l4("Entering...\n");
node = (CgXmlNode *)malloc(sizeof(CgXmlNode));
if ( NULL != node )
{
cg_list_node_init((CgList *)node);
node->name = cg_string_new();
node->value = cg_string_new();
node->attrList = cg_xml_attributelist_new();
node->nodeList = cg_xml_nodelist_new();
node->parentNode = NULL;
node->userData = NULL;
node->userDataDestructorFunc = NULL;
}
cg_log_debug_l4("Leaving...\n");
return node;
}
CgUpnpAvResourceData* cg_upnpav_resource_data_new()
{
CgUpnpAvResourceData* resData;
resData = (CgUpnpAvResourceData*)malloc(sizeof(CgUpnpAvResourceData));
resData->mimeType = cg_string_new();
resData->dlnaAttr = cg_string_new();
return resData;
}
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;
}
BOOL cg_bittorrent_metainfo_save(CgBittorrentMetainfo *cbm, char *fileName)
{
FILE *fp;
CgString *str;
if (!cbm)
return FALSE;
str = cg_string_new();
if (!str)
return FALSE;
if (!cg_bittorrent_metainfo_tostring(cbm, str)) {
cg_string_delete(str);
return FALSE;
}
fp = fopen(fileName, "wb");
if (fp) {
fwrite(cg_string_getvalue(str), sizeof(char), cg_string_length(str), fp);
fclose(fp);
}
cg_string_delete(str);
return (fp ? TRUE : FALSE);
}
CgUpnpStateVariable *cg_upnp_statevariable_new()
{
CgUpnpStateVariable *statVar;
cg_log_debug_l4("Entering...\n");
statVar = (CgUpnpStateVariable *)malloc(sizeof(CgUpnpStateVariable));
if ( NULL != statVar )
{
cg_list_node_init((CgList *)statVar);
statVar->parentService = NULL;
statVar->stateVarNode = NULL;
statVar->value = cg_string_new();
statVar->upnpStatus = cg_upnp_status_new();
cg_upnp_statevariable_setlistener(statVar, NULL);
cg_upnp_statevariable_setuserdata(statVar, NULL);
}
cg_log_debug_l4("Leaving...\n");
return statVar;
}
void cg_xml_node_print(CgXmlNode *node)
{
CgString *str = cg_string_new();
cg_xml_node_tostring(node, TRUE, str);
printf("%s", cg_string_getvalue(str));
cg_string_delete(str);
}
BOOL cg_upnp_ssdpresponse_server_post(CgUpnpSSDPResponseServer *server, CgUpnpSSDPRequest *ssdpReq)
{
CgUpnpHttpUSocket *httpuSock;
char *ifAddr;
const char *ssdpAddr;
CgString *ssdpMsg;
size_t sentLen = 0;
cg_log_debug_l4("Entering...\n");
httpuSock = cg_upnp_ssdpresponse_server_getsocket(server);
ifAddr = cg_socket_getaddress(httpuSock);
ssdpAddr = cg_upnp_ssdp_gethostaddress(ifAddr);
cg_upnp_ssdprequest_sethost(ssdpReq, ssdpAddr, CG_UPNP_SSDP_PORT);
ssdpMsg = cg_string_new();
cg_upnp_ssdprequest_tostring(ssdpReq, ssdpMsg);
sentLen = cg_socket_sendto(httpuSock, ssdpAddr, CG_UPNP_SSDP_PORT, cg_string_getvalue(ssdpMsg), cg_string_length(ssdpMsg));
cg_string_delete(ssdpMsg);
cg_log_debug_l4("Leaving...\n");
return (sentLen > 0);
}
CgHttpPersistentConnection *cg_http_persistentconnection_new(void)
{
CgHttpPersistentConnection *new_node;
cg_log_debug_l4("Entering...\n");
new_node = (CgHttpPersistentConnection *)malloc(sizeof(CgHttpPersistentConnection));
if ( NULL != new_node )
{
new_node->headFlag = FALSE;
new_node->next = NULL;
new_node->prev = NULL;
new_node->host = cg_string_new();
new_node->port = 0;
new_node->cacheData = NULL;
new_node->timestamp = 0;
}
return new_node;
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_packet_init(CgHttpPacket *httpPkt)
{
cg_log_debug_l4("Entering...\n");
httpPkt->headerList = cg_http_headerlist_new();
httpPkt->content = cg_string_new();
cg_log_debug_l4("Leaving...\n");
}
CgHttpHeader *cg_http_header_new()
{
CgHttpHeader *header;
cg_log_debug_l4("Entering...\n");
header = (CgHttpHeader *)malloc(sizeof(CgHttpHeader));
if ( NULL != header )
{
cg_list_node_init((CgList *)header);
header->name = cg_string_new();
header->value = cg_string_new();
}
return header;
cg_log_debug_l4("Leaving...\n");
}
void cg_upnp_event_subscription_request_settimeout(void *subReq, long timeout)
{
CgString *timeoutBuf;
cg_log_debug_l4("Entering...\n");
timeoutBuf = cg_string_new();
cg_http_packet_setheadervalue(((CgHttpPacket*)subReq), CG_HTTP_TIMEOUT, cg_upnp_event_subscription_totimeoutheaderstring(timeout, timeoutBuf));
cg_string_delete(timeoutBuf);
cg_log_debug_l4("Leaving...\n");
}
void cg_upnp_event_subscription_response_settimeout(CgUpnpSubscriptionResponse *subRes, long value)
{
CgString *buf;
cg_log_debug_l4("Entering...\n");
buf = cg_string_new();
cg_http_packet_setheadervalue((CgHttpPacket*)subRes, CG_HTTP_TIMEOUT, cg_upnp_event_subscription_totimeoutheaderstring(value, buf));
cg_string_delete(buf);
cg_log_debug_l4("Leaving...\n");
}
CgDatagramPacket *cg_socket_datagram_packet_new()
{
CgDatagramPacket *dgmPkt;
cg_log_debug_l4("Entering...\n");
dgmPkt = (CgDatagramPacket *)malloc(sizeof(CgDatagramPacket));
if ( NULL != dgmPkt )
{
dgmPkt->data = cg_string_new();
dgmPkt->localAddress = cg_string_new();
dgmPkt->remoteAddress = cg_string_new();
cg_socket_datagram_packet_setlocalport(dgmPkt, 0);
cg_socket_datagram_packet_setremoteport(dgmPkt, 0);
}
return dgmPkt;
cg_log_debug_l4("Leaving...\n");
}
CgNetworkInterface *cg_net_interface_new()
{
CgNetworkInterface *netIf;
cg_log_debug_l4("Entering...\n");
netIf = (CgNetworkInterface *)malloc(sizeof(CgNetworkInterface));
if ( NULL != netIf )
{
cg_list_node_init((CgList *)netIf);
netIf->name = cg_string_new();
netIf->ipaddr = cg_string_new();
netIf->netmask = cg_string_new();
cg_net_interface_setindex(netIf, 0);
memset(netIf->macaddr, 0, (size_t)CG_NET_MACADDR_SIZE);
}
cg_log_debug_l4("Leaving...\n");
return netIf;
}
CgDictionary *cg_net_uri_getquerydictionary(CgNetURI *uri)
{
char *query;
int queryOffset;
int eqIdx, ampIdx;
CgString *paramName;
CgString *paramValue;
if (NULL == uri->queryDictionary)
uri->queryDictionary = cg_dictionary_new();
paramName = cg_string_new();
paramValue = cg_string_new();
query = cg_net_uri_getquery(uri);
queryOffset = 0;
eqIdx = cg_strstr(query, "=");
while (0 < eqIdx) {
ampIdx = cg_strstr(query + queryOffset, "&");
if (ampIdx <= 0) {
ampIdx = cg_strstr(query + queryOffset, "#");
if (ampIdx <= 0)
ampIdx = cg_strlen(query + queryOffset);
}
if (ampIdx <= eqIdx)
break;
cg_string_setnvalue(paramName, query + queryOffset, eqIdx);
cg_string_setnvalue(paramValue, query + queryOffset + eqIdx + 1, (ampIdx - eqIdx -1));
cg_dictionary_setvalue(uri->queryDictionary, cg_string_getvalue(paramName), cg_string_getvalue(paramValue));
queryOffset += ampIdx + 1;
eqIdx = cg_strstr(query + queryOffset, "=");
}
cg_string_delete(paramName);
cg_string_delete(paramValue);
return uri->queryDictionary;
}
CgUpnpProperty *cg_upnp_property_new()
{
CgUpnpProperty *prop;
cg_log_debug_l4("Entering...\n");
prop = (CgUpnpProperty *)malloc(sizeof(CgUpnpProperty));
if ( NULL != prop )
{
cg_list_node_init((CgList *)prop);
prop->name = cg_string_new();
prop->value = cg_string_new();
prop->sid = cg_string_new();
cg_upnp_property_setseq(prop, 0);
}
return prop;
cg_log_debug_l4("Leaving...\n");
}
/**
* Create a new control point. Does not start any threads.
*
* @return A newly-created CgUpnpControlPoint
*/
CgUpnpControlPoint *cg_upnp_controlpoint_new()
{
CgUpnpControlPoint *ctrlPoint;
cg_log_debug_l4("Entering...\n");
ctrlPoint = (CgUpnpControlPoint *)malloc(sizeof(CgUpnpControlPoint));
if ( NULL != ctrlPoint )
{
#ifdef CG_HTTP_USE_PERSISTENT_CONNECTIONS
cg_http_persistentconnection_init();
#endif
ctrlPoint->mutex = cg_mutex_new();
ctrlPoint->deviceRootNodeList = cg_xml_nodelist_new();
ctrlPoint->deviceList = cg_upnp_devicelist_new();
ctrlPoint->ssdpServerList = cg_upnp_ssdp_serverlist_new();
ctrlPoint->ssdpResServerList = cg_upnp_ssdpresponse_serverlist_new();
ctrlPoint->httpServerList = cg_http_serverlist_new();
ctrlPoint->httpEventURI = cg_string_new();
ctrlPoint->eventListeners = cg_upnp_eventlistenerlist_new();
/* Expiration handling */
ctrlPoint->expThread = cg_thread_new();
cg_thread_setaction(ctrlPoint->expThread, cg_upnp_controlpoint_expirationhandler);
cg_thread_setuserdata(ctrlPoint->expThread, ctrlPoint);
ctrlPoint->expMutex = cg_mutex_new();
ctrlPoint->expCond = cg_cond_new();
ctrlPoint->ifCache = cg_net_interfacelist_new();
cg_upnp_controlpoint_setssdplistener(ctrlPoint, NULL);
cg_upnp_controlpoint_setssdpresponselistener(ctrlPoint, NULL);
cg_upnp_controlpoint_sethttplistener(ctrlPoint, NULL);
cg_upnp_controlpoint_setdevicelistener(ctrlPoint, NULL);
cg_upnp_controlpoint_setssdpresponseport(ctrlPoint, CG_UPNP_CONTROLPOINT_SSDP_RESPONSE_DEFAULT_PORT);
cg_upnp_controlpoint_setssdpsearchmx(ctrlPoint, CG_UPNP_CONTROLPOINT_SSDP_DEFAULT_SEARCH_MX);
cg_upnp_controlpoint_seteventport(ctrlPoint, CG_UPNP_CONTROLPOINT_HTTP_EVENT_DEFAULT_PORT);
cg_upnp_controlpoint_seteventsuburi(ctrlPoint, CG_UPNP_CONTROLPOINT_HTTP_EVENTSUB_URI);
cg_upnp_controlpoint_setuserdata(ctrlPoint, NULL);
}
cg_log_debug_l4("Leaving...\n");
return ctrlPoint;
}
BOOL cg_upnp_ssdp_socket_postresponse(CgUpnpSSDPSocket *ssdpSock, CgUpnpSSDPResponse *ssdpRes, const char *host, int port)
{
CgString *ssdpMsg;
size_t ssdpMsgLen;
BOOL postSuccess;
cg_log_debug_l4("Entering...\n");
ssdpMsg = cg_string_new();
cg_upnp_ssdpresponse_tostring(ssdpRes, ssdpMsg);
ssdpMsgLen = cg_string_length(ssdpMsg);
postSuccess = (cg_socket_sendto(ssdpSock, host, port, cg_string_getvalue(ssdpMsg), ssdpMsgLen) == ssdpMsgLen) ? TRUE : FALSE;
cg_string_delete(ssdpMsg);
cg_log_debug_l4("Leaving...\n");
return postSuccess;
}
static BOOL cg_upnp_ssdp_socket_notify(CgUpnpSSDPSocket *ssdpSock, CgUpnpSSDPRequest *ssdpReq, const char *ssdpAddr)
{
CgString *ssdpMsg;
size_t sentLen;
cg_log_debug_l4("Entering...\n");
cg_upnp_ssdprequest_setmethod(ssdpReq, CG_HTTP_NOTIFY);
ssdpMsg = cg_string_new();
cg_upnp_ssdprequest_tostring(ssdpReq, ssdpMsg);
sentLen = cg_socket_sendto(ssdpSock, ssdpAddr, CG_UPNP_SSDP_PORT, cg_string_getvalue(ssdpMsg), cg_string_length(ssdpMsg));
cg_string_delete(ssdpMsg);
cg_log_debug_l4("Leaving...\n");
return (0 < sentLen) ? TRUE : FALSE;
}
void cg_upnpav_resource_updateattributes(CgUpnpAvResource *res)
{
CgUpnpAvResourceData *nodeData;
CgString *resAttr;
char *mimeType;
char *dlnaAttr;
nodeData = (CgUpnpAvResourceData *)cg_xml_node_getuserdata(res);
mimeType = (0 < cg_string_length(nodeData->mimeType)) ? cg_string_getvalue(nodeData->mimeType) : "*/*";
dlnaAttr = (0 < cg_string_length(nodeData->dlnaAttr)) ? cg_string_getvalue(nodeData->dlnaAttr) : "*";
resAttr = cg_string_new();
cg_string_addvalue(resAttr, "http-get:*:");
cg_string_addvalue(resAttr, mimeType);
cg_string_addvalue(resAttr, ":");
cg_string_addvalue(resAttr, dlnaAttr);
cg_xml_node_setattribute(res, CG_UPNPAV_RESOURCE_PROTOCOLINFO, cg_string_getvalue(resAttr));
cg_string_delete(resAttr);
}
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);
}
void cg_upnp_event_subscription_request_setsid(CgUpnpSubscriptionRequest *subReq, const char *sid)
{
CgString *headerSID;
ssize_t uuidIdx;
cg_log_debug_l4("Entering...\n");
headerSID = cg_string_new();
uuidIdx = cg_strstr(sid, CG_UPNP_ST_UUID_DEVICE);
if (uuidIdx < 0)
cg_string_addvalue(headerSID, CG_UPNP_ST_UUID_DEVICE ":");
cg_string_addvalue(headerSID, sid);
cg_http_packet_setheadervalue(((CgHttpPacket*)subReq), CG_HTTP_SID, cg_string_getvalue(headerSID));
cg_string_delete(headerSID);
cg_log_debug_l4("Leaving...\n");
}
CgSocket *cg_socket_new(int type)
{
CgSocket *sock;
cg_log_debug_l4("Entering...\n");
cg_socket_startup();
sock = (CgSocket *)malloc(sizeof(CgSocket));
if ( NULL != sock )
{
#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(ITRON)
sock->id = INVALID_SOCKET;
#else
sock->id = -1;
#endif
cg_socket_settype(sock, type);
cg_socket_setdirection(sock, CG_NET_SOCKET_NONE);
sock->ipaddr = cg_string_new();
cg_socket_setaddress(sock, "");
cg_socket_setport(sock, -1);
#if defined(ITRON)
sock->sendWinBuf = NULL;
sock->recvWinBuf = NULL;
#endif
#if defined(CG_USE_OPENSSL)
sock->ctx = NULL;
sock->ssl = NULL;
#endif
}
cg_log_debug_l4("Leaving...\n");
return sock;
}
void cg_upnpav_dmr_addprotocolinfo(CgUpnpAvRenderer* dmr, CgUpnpAvProtocolInfo* info)
{
CgString* protocolInfos;
CgUpnpAvProtocolInfo* protocolInfo;
CgUpnpService* service;
CgUpnpStateVariable* stateVar;
cg_upnpav_protocolinfolist_add(dmr->protocolInfoList, info);
protocolInfos = cg_string_new();
for (protocolInfo = cg_upnpav_dmr_getprotocolinfos(dmr); protocolInfo; protocolInfo = cg_upnpav_protocolinfo_next(protocolInfo)) {
if (0 < cg_string_length(protocolInfos))
cg_string_addvalue(protocolInfos, ",");
cg_string_addvalue(protocolInfos, cg_upnpav_protocolinfo_getstring(protocolInfo));
}
service = cg_upnp_device_getservicebyexacttype(dmr->dev, CG_UPNPAV_DMR_CONNECTIONMANAGER_SERVICE_TYPE);
stateVar = cg_upnp_service_getstatevariablebyname(service, CG_UPNPAV_DMR_CONNECTIONMANAGER_SINKPROTOCOLINFO);
cg_upnp_statevariable_setvalue(stateVar, cg_string_getvalue(protocolInfos));
cg_string_delete(protocolInfos);
}
BOOL cg_upnpav_dms_conmgr_actionreceived(CgUpnpAction* action)
{
CgUpnpAvServer* dms;
CgUpnpDevice* dev;
char* actionName;
CgUpnpArgument* arg;
CgString* protocolInfos;
CgUpnpAvProtocolInfo* protocolInfo;
actionName = (char*)cg_upnp_action_getname(action);
if (cg_strlen(actionName) <= 0)
return FALSE;
dev = (CgUpnpDevice*)cg_upnp_service_getdevice(cg_upnp_action_getservice(action));
if (!dev)
return FALSE;
dms = (CgUpnpAvServer*)cg_upnp_device_getuserdata(dev);
if (!dms)
return FALSE;
/* GetProtocolInfo*/
if (cg_streq(actionName, CG_UPNPAV_DMS_CONNECTIONMANAGER_GET_PROTOCOL_INFO)) {
arg = cg_upnp_action_getargumentbyname(action, CG_UPNPAV_DMS_CONNECTIONMANAGER_SOURCE);
if (!arg)
return FALSE;
protocolInfos = cg_string_new();
for (protocolInfo = cg_upnpav_dms_getprotocolinfos(dms); protocolInfo; protocolInfo = cg_upnpav_protocolinfo_next(protocolInfo)) {
if (0 < cg_string_length(protocolInfos))
cg_string_addvalue(protocolInfos, ",");
cg_string_addvalue(protocolInfos, cg_upnpav_protocolinfo_getstring(protocolInfo));
}
cg_upnp_argument_setvalue(arg, cg_string_getvalue(protocolInfos));
cg_string_delete(protocolInfos);
return TRUE;
}
return FALSE;
}
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 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);
}
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");
}
