CWBool CWParseSettingsFile()
{
char *line = NULL;
gSettingsFile = fopen (CW_SETTINGS_FILE, "rb");
if (gSettingsFile == NULL) {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
CW_CREATE_ARRAY_ERR(gDefaultQosValues, NUM_QOS_PROFILES, WTPQosValues, return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL););
// creates a semaphore
CWBool CWThreadCreateSem(CWThreadSem *semPtr, int value) {
if(semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
// we use named semaphore on platforms that support only them (e.g. Mac OS X)
#ifdef CW_USE_NAMED_SEMAPHORES
{
static int semCount = 0;
char name[32];
snprintf(name, 32, "/CWSem-%d-%4.4d", getpid(), semCount++);
if ( (semPtr->semPtr = sem_open(name, O_CREAT, 0600, value)) == (sem_t *)SEM_FAILED ) {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
} else {
sem_unlink(name);
}
}
#else
if ( sem_init(semPtr, 0, value) < 0 ) {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
#endif
return CW_TRUE;
}
CWBool CWParseSettingsFile()
{
char *line = NULL;
gSettingsFile = fopen (CW_SETTINGS_FILE, "rb");
if (gSettingsFile == NULL) {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
while((line = (char*)CWGetCommand(gSettingsFile)) != NULL)
{
char* startTag=NULL;
char* endTag=NULL;
if((startTag=strchr (line, '<'))==NULL)
{
CW_FREE_OBJECT(line);
continue;
}
if((endTag=strchr (line, '>'))==NULL)
{
CW_FREE_OBJECT(line);
continue;
}
if (!strncmp(startTag+1, "IF_NAME", endTag-startTag-1))
{
char* startValue=NULL;
char* endValue=NULL;
int offset = 0;
CWExtractValue(endTag, &startValue, &endValue, &offset);
CW_CREATE_STRING_ERR(gInterfaceName, offset, return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY,NULL););
strncpy(gInterfaceName, startValue, offset);
gInterfaceName[offset] ='\0';
CWLog(": %s", gInterfaceName);
CW_FREE_OBJECT(line);
continue;
}
CWBool CWThreadTimedSemWait(CWThreadTimedSem *semPtr, time_t sec, time_t nsec) {
#ifdef HAVE_SEM_TIMEDWAIT
struct timespec timeout;
time_t t;
#ifdef CW_USE_NAMED_SEMAPHORES
if(semPtr == NULL || semPtr->semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#else
if(semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#endif
CWDebugLog("Sem Timed Wait");
time(&t);
timeout.tv_sec = t + sec;
timeout.tv_nsec = nsec;
#ifdef CW_USE_NAMED_SEMAPHORES
while(sem_timedwait(semPtr->semPtr, &timeout) < 0 ) {
#else
while(sem_timedwait(semPtr, &timeout) < 0 ) {
#endif
if(errno == EINTR) { continue;}
else if(errno == ETIMEDOUT) {
CWDebugLog("sem_timedwait expired");
return CWErrorRaise(CW_ERROR_TIME_EXPIRED, NULL);
} else {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
}
#else
fd_set fset;
int r;
struct timeval timeout;
char dummy;
if(semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
CWDebugLog("Timed Sem Wait");
FD_ZERO(&fset);
FD_SET((*semPtr)[0], &fset);
timeout.tv_sec = sec;
timeout.tv_usec = nsec / 1000;
CWDebugLog("Timed Sem Wait Before Select");
while((r = select(((*semPtr)[0])+1, &fset, NULL, NULL, &timeout)) <= 0) {
CWDebugLog("Timed Sem Wait Select error");
if(r == 0) {
CWDebugLog("Timed Sem Wait Timeout");
return CWErrorRaise(CW_ERROR_TIME_EXPIRED, NULL);
} else if(errno == EINTR) {
timeout.tv_sec = sec;
timeout.tv_usec = nsec / 1000;
continue;
}
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
CWDebugLog("Timed Sem Wait After Select");
// ready to read
while(read((*semPtr)[0], &dummy, 1) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
// send ack (three-way handshake)
while(send((*semPtr)[0], &dummy, 1, 0) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_SENDING);
}
timeout.tv_sec = 2;
timeout.tv_usec = 0;
CWDebugLog("Timed Sem Wait Before Select 2");
while((r = select(((*semPtr)[0])+1, &fset, NULL, NULL, &timeout)) <= 0) {
CWDebugLog("Timed Sem Wait Select error 2");
if(r == 0) {
CWDebugLog("Timed Sem Wait Timeout 2");
return CWErrorRaise(CW_ERROR_TIME_EXPIRED, NULL);
} else if(errno == EINTR) {
timeout.tv_sec = 2;
timeout.tv_usec = 0;
continue;
}
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
CWDebugLog("Timed Sem Wait After Select 2");
// read ack
while(read((*semPtr)[0], &dummy, 1) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
#endif
CWDebugLog("End of Timed Sem Wait");
return CW_TRUE;
}
CWBool CWThreadTimedSemPost(CWThreadTimedSem *semPtr) {
#ifdef HAVE_SEM_TIMEDWAIT
return CWThreadSemPost(semPtr);
#else
char dummy = 'D';
fd_set fset;
int r;
struct timeval timeout;
if(semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
CWDebugLog("Timed Sem Post");
while(send((*semPtr)[1], &dummy, 1, 0) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_SENDING);
}
// read ack (three-way handshake)
FD_ZERO(&fset);
FD_SET((*semPtr)[1], &fset);
timeout.tv_sec = 2;
timeout.tv_usec = 0;
CWDebugLog("Timed Sem Post Before Select");
while((r = select(((*semPtr)[1])+1, &fset, NULL, NULL, &timeout)) <= 0) {
CWDebugLog("Timed Sem Post Select Error");
if(r == 0) { // timeout, server is not responding
// note: this is not an error in a traditional semaphore, btw it's an error
// according to our logic
CWDebugLog("Timed Sem Post Timeout");
return CWErrorRaise(CW_ERROR_GENERAL, "Nobody is Waiting on this Sem");
} else if(errno == EINTR) {
timeout.tv_sec = 2;
timeout.tv_usec = 0;
continue;
}
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
CWDebugLog("Timed Sem Post After Select");
while(read((*semPtr)[1], &dummy, 1) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
// send ack
while(send((*semPtr)[1], &dummy, 1, 0) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_SENDING);
}
CWDebugLog("End of Sem Post");
return CW_TRUE;
#endif
}
// wrappers for pthread_key_*()
CWBool CWThreadCreateSpecific(CWThreadSpecific *specPtr, void (*destructor)(void *)) {
if(specPtr == NULL) return CW_FALSE; // NULL destructor is allowed
if(pthread_key_create(specPtr, destructor) != 0) {
CWDebugLog("Error pthread key create");
return CW_FALSE;
}
return CW_TRUE;
}
void CWThreadDestroySpecific(CWThreadSpecific *specPtr) {
if(specPtr == NULL) return;
pthread_key_delete(*specPtr);
}
void *CWThreadGetSpecific(CWThreadSpecific *specPtr) {
if(specPtr == NULL) return NULL;
return pthread_getspecific(*specPtr);
}
CWBool CWThreadSetSpecific(CWThreadSpecific *specPtr, void *valPtr) {
if(specPtr == NULL || valPtr == NULL) return CW_FALSE;
switch(pthread_setspecific(*specPtr, valPtr)) {
case 0: // success
break;
case ENOMEM:
return CW_FALSE;
default:
return CW_FALSE;
}
return CW_TRUE;
}
// terminate the calling thread
void CWExitThread() {
printf("\n*** Exit Thread ***\n");
pthread_exit((void *) 0);
}
// perform wait on a semaphore
CWBool CWThreadSemWait(CWThreadSem *semPtr) {
#ifdef CW_USE_NAMED_SEMAPHORES
if(semPtr == NULL || semPtr->semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#else
if(semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#endif
//CWDebugLog("Sem Wait");
#ifdef CW_USE_NAMED_SEMAPHORES
while(sem_wait(semPtr->semPtr) < 0 ) {
#else
while(sem_wait(semPtr) < 0 ) {
#endif
if(errno == EINTR) continue;
else {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
}
return CW_TRUE;
}
// perform post on a semaphore
CWBool CWThreadSemPost(CWThreadSem *semPtr) {
#ifdef CW_USE_NAMED_SEMAPHORES
if(semPtr == NULL || semPtr->semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#else
if(semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#endif
#ifdef CW_USE_NAMED_SEMAPHORES
if(sem_post(semPtr->semPtr) < 0 ) {
#else
if(sem_post(semPtr) < 0 ) {
#endif
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
return CW_TRUE;
}
// get the value of a semaphore
CWBool CWThreadSemGetValue(CWThreadSem *semPtr, int *valuePtr) {
#ifdef CW_USE_NAMED_SEMAPHORES
if(valuePtr == NULL || semPtr == NULL || semPtr->semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#else
if(valuePtr == NULL || semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
#endif
#ifdef CW_USE_NAMED_SEMAPHORES
if(sem_getvalue(semPtr->semPtr, valuePtr) < 0) { // note: broken on Mac OS X? Btw we don't need it
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
#else
if(sem_getvalue(semPtr, valuePtr) < 0) {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
#endif
if(*valuePtr < 0 ) {
*valuePtr = 0;
}
return CW_TRUE;
}
__inline__ sem_t *CWThreadGetSemT(CWThreadSem *semPtr) {
#ifdef CW_USE_NAMED_SEMAPHORES
return (semPtr->semPtr);
#else
return semPtr;
#endif
}
// creates a semaphore that can be used with CWThreadTimedSemWait(). This type of semaphore
// is different from CWThreadSemaphore to support platforms that don't have sem_timedwait() (e.g. Mac OS X)
CWBool CWThreadCreateTimedSem(CWThreadTimedSem *semPtr, int value) {
#ifdef HAVE_SEM_TIMEDWAIT
return CWThreadCreateSem(semPtr, value);
#else
// if we don't have sem_timedwait(), the timed semaphore is a pair of unix domain sockets.
// We write a dummy packet on a socket (client) when we want to post, and select() with timer on the other socket
// when we want to wait.
struct sockaddr_un serverAddr, clientAddr;
int i;
if(semPtr == NULL) return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
if((((*semPtr)[0] = socket(AF_LOCAL, SOCK_DGRAM, 0)) < 0) ||
(((*semPtr)[1] = socket(AF_LOCAL, SOCK_DGRAM, 0)) < 0)) { // create a pair of datagram unix domain socket
close((*semPtr)[0]);
CWErrorRaiseSystemError(CW_ERROR_CREATING);
}
CW_ZERO_MEMORY(&serverAddr, sizeof(serverAddr));
serverAddr.sun_family = AF_LOCAL;
if(tmpnam((char*) &(serverAddr.sun_path)) == NULL) {
CWErrorRaiseSystemError(CW_ERROR_CREATING);
}
CW_ZERO_MEMORY(&clientAddr, sizeof(clientAddr));
clientAddr.sun_family = AF_LOCAL;
if(tmpnam((char*) &(clientAddr.sun_path)) == NULL) {
CWErrorRaiseSystemError(CW_ERROR_CREATING);
}
if( (bind((*semPtr)[0], (struct sockaddr*) &serverAddr, sizeof(serverAddr)) < 0) ||
(bind((*semPtr)[1], (struct sockaddr*) &clientAddr, sizeof(clientAddr)) < 0) ||
(connect((*semPtr)[1], (struct sockaddr*) &serverAddr, sizeof(serverAddr)) < 0) || // connect each socket to the other
(connect((*semPtr)[0], (struct sockaddr*) &clientAddr, sizeof(clientAddr)) < 0)
) {
close((*semPtr)[0]);
close((*semPtr)[1]);
CWErrorRaiseSystemError(CW_ERROR_CREATING);
}
for(i = 0; i < value; i++) {
if(!CWThreadTimedSemPost(semPtr)) return CW_FALSE;
}
return CW_TRUE;
#endif
}
// CW_TRUE if the semaphore has zero value, CW_FALSE otherwise
CWBool CWThreadTimedSemIsZero(CWThreadTimedSem *semPtr) {
#ifdef HAVE_SEM_TIMEDWAIT
int value;
if(!CWThreadSemGetValue(semPtr, &value)) return CW_FALSE;
return (value==0) ? CW_TRUE : CW_FALSE;
#else
fd_set fset;
int r;
struct timeval timeout;
if(semPtr == NULL) return CW_FALSE;
FD_ZERO(&fset);
FD_SET((*semPtr)[0], &fset);
FD_SET((*semPtr)[1], &fset);
timeout.tv_sec = 0; // poll
timeout.tv_usec = 0;
while((r=select(max((*semPtr)[1], (*semPtr)[0])+1, &fset, NULL, NULL, &timeout)) < 0) {
if(errno == EINTR) {
timeout.tv_sec = 0;
timeout.tv_usec = 0;
continue;
}
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
return (r==0) ? CW_TRUE : CW_FALSE;
#endif
}
CWBool CWThreadTimedSemSetValue(CWThreadTimedSem *semPtr, int value) {
#ifdef HAVE_SEM_TIMEDWAIT
// note: we can implement this, but our implemntation does't really need it in case
// of a system semaphore. This is useful for our Unix Domain Socket Hack
return CW_TRUE;
//return CWErrorRaise(CW_ERROR_NEED_RESOURCE, "Operation Not Supported");
#else
fd_set fset;
int r, i;
struct timeval timeout;
if(semPtr == NULL) return CW_FALSE;
FD_ZERO(&fset);
FD_SET((*semPtr)[0], &fset);
FD_SET((*semPtr)[1], &fset);
timeout.tv_sec = 0; // poll
timeout.tv_usec = 0;
// first, remove all the pending packets
CW_REPEAT_FOREVER {
char dummy;
while((r=select(max((*semPtr)[1], (*semPtr)[0])+1, &fset, NULL, NULL, &timeout)) < 0) {
if(errno == EINTR) {
timeout.tv_sec = 0;
timeout.tv_usec = 0;
continue;
}
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
if(r == 0) break;
if(FD_ISSET((*semPtr)[0], &fset)) {
while(read((*semPtr)[0], &dummy, 1) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
}
if(FD_ISSET((*semPtr)[1], &fset)) {
while(read((*semPtr)[1], &dummy, 1) < 0) {
if(errno == EINTR) continue;
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
}
}
// second, send n packets, where n is the value we want to set for the semaphore
for(i = 0; i < value; i++) {
if(!CWThreadTimedSemPost(semPtr)) return CW_FALSE;
}
return CW_TRUE;
#endif
}
void CWThreadDestroyTimedSem(CWThreadTimedSem *semPtr) {
#ifdef HAVE_SEM_TIMEDWAIT
CWThreadDestroySem(semPtr);
#else
if(semPtr == NULL) return;
close((*semPtr)[0]);
close((*semPtr)[1]);
#endif
}
CWBool CWParseSettingsFile()
{
char line[CW_BUFFER_SIZE];
gSettingsFile = fopen(gCWSettingsFileName, "rb");
if (gSettingsFile == NULL) {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
while (CWGetCommand(gSettingsFile, line, sizeof(line)) == CW_TRUE) {
char *startTag = NULL;
char *endTag = NULL;
char *Value = NULL;
if ((startTag = strchr(line, '<')) == NULL)
continue;
startTag++;
if ((endTag = strchr(startTag, '>')) == NULL)
continue;
*endTag++ = '\0';
Value = ltrim(endTag);
if (!strcmp(startTag, "IF_NAME")) {
if (!(gInterfaceName = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gInterfaceName);
}
else if (!strcmp(startTag, "WTP_ETH_IF_NAME")) {
if (!(gEthInterfaceName = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gEthInterfaceName);
}
else if (!strcmp(startTag, "RADIO_0_IF_NAME")) {
if (!(gRadioInterfaceName_0 = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gRadioInterfaceName_0);
}
else if (!strcmp(startTag, "BASE_MAC_IF_NAME")) {
if (!(gBaseMACInterfaceName = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gBaseMACInterfaceName);
}
else if (!strcmp(startTag, "BOARD_REVISION_NO")) {
gBoardReversionNo = atoi(Value);
CWLog(": %d", gBoardReversionNo);
}
else if (!strcmp(startTag, "WTP_HOSTAPD_PORT")) {
gHostapd_port = atoi(Value);
CWLog(": %d", gHostapd_port);
}
else if (!strcmp(startTag, "WTP_HOSTAPD_UNIX_PATH")) {
if (!(gHostapd_unix_path = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gHostapd_unix_path);
}
else if (!strcmp(startTag, "WTP_MODEL_NUM")) {
if (!(gWtpModelNumber = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gWtpModelNumber);
}
else if (!strcmp(startTag, "WTP_SERIAL_NUM")) {
if (!(gWtpSerialNumber = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gWtpSerialNumber);
}
else if (!strcmp(startTag, "WTP_HARDWARE_VERSION")) {
if (!(gWtpHardwareVersion = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gWtpHardwareVersion);
}
else if (!strcmp(startTag, "WTP_ACTIVE_SOFTWARE_VERSION")) {
if (!(gWtpActiveSoftwareVersion = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gWtpActiveSoftwareVersion);
}
else if (!strcmp(startTag, "WTP_BOOT_VERSION")) {
if (!(gWtpBootVersion = ralloc_strdup(NULL, Value)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWLog(": %s", gWtpBootVersion);
}
else
CWLog(": unknown Tag: %s = %s", startTag, Value);
}
return CW_TRUE;
}
CWBool CWParseSettingsFile()
{
char line[CW_BUFFER_SIZE];
gSettingsFile = fopen(gCWSettingsFileName, "rb");
if (gSettingsFile == NULL) {
CWErrorRaiseSystemError(CW_ERROR_GENERAL);
}
if (!(gDefaultQosValues = ralloc_array(NULL, WTPQosValues, NUM_QOS_PROFILES)))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
while (CWGetCommand(gSettingsFile, line, sizeof(line)) == CW_TRUE) {
char *startTag = NULL;
char *endTag = NULL;
if ((startTag = strchr(line, '<')) == NULL)
continue;
if ((endTag = strchr(line, '>')) == NULL)
continue;
if (!strncmp(startTag + 1, "CWMIN_VOICE", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMIN_DEFAULT;
gDefaultQosValues[VOICE_QUEUE_INDEX].cwMin = value;
CWDebugLog("CWMIN_VOICE: %d", gDefaultQosValues[VOICE_QUEUE_INDEX].cwMin);
continue;
}
if (!strncmp(startTag + 1, "CWMAX_VOICE", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMAX_DEFAULT;
gDefaultQosValues[VOICE_QUEUE_INDEX].cwMax = value;
CWDebugLog("CWMAX_VOICE: %d", gDefaultQosValues[VOICE_QUEUE_INDEX].cwMax);
continue;
}
if (!strncmp(startTag + 1, "AIFS_VOICE", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = AIFS_DEFAULT;
gDefaultQosValues[VOICE_QUEUE_INDEX].AIFS = value;
CWDebugLog("AIFS_VOICE: %d", gDefaultQosValues[VOICE_QUEUE_INDEX].AIFS);
continue;
}
if (!strncmp(startTag + 1, "CWMIN_VIDEO", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMIN_DEFAULT;
gDefaultQosValues[VIDEO_QUEUE_INDEX].cwMin = value;
CWDebugLog("CWMIN_VIDEO: %d", gDefaultQosValues[VIDEO_QUEUE_INDEX].cwMin);
continue;
}
if (!strncmp(startTag + 1, "CWMAX_VIDEO", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMAX_DEFAULT;
gDefaultQosValues[VIDEO_QUEUE_INDEX].cwMax = value;
CWDebugLog("CWMAX_VIDEO: %d", gDefaultQosValues[VIDEO_QUEUE_INDEX].cwMax);
continue;
}
if (!strncmp(startTag + 1, "AIFS_VIDEO", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = AIFS_DEFAULT;
gDefaultQosValues[VIDEO_QUEUE_INDEX].AIFS = value;
CWDebugLog("AIFS_VIDEO: %d", gDefaultQosValues[VIDEO_QUEUE_INDEX].AIFS);
continue;
}
if (!strncmp(startTag + 1, "CWMIN_BEST_EFFORT", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMIN_DEFAULT;
gDefaultQosValues[BESTEFFORT_QUEUE_INDEX].cwMin = value;
CWDebugLog("CWMIN_BEST_EFFORT: %d", gDefaultQosValues[BESTEFFORT_QUEUE_INDEX].cwMin);
continue;
}
if (!strncmp(startTag + 1, "CWMAX_BEST_EFFORT", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMAX_DEFAULT;
gDefaultQosValues[BESTEFFORT_QUEUE_INDEX].cwMax = value;
CWDebugLog("CWMAX_BEST_EFFORT: %d", gDefaultQosValues[BESTEFFORT_QUEUE_INDEX].cwMax);
continue;
}
if (!strncmp(startTag + 1, "AIFS_BEST_EFFORT", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = AIFS_DEFAULT;
gDefaultQosValues[BESTEFFORT_QUEUE_INDEX].AIFS = value;
CWDebugLog("AIFS_BEST_EFFORT: %d", gDefaultQosValues[BESTEFFORT_QUEUE_INDEX].AIFS);
continue;
}
if (!strncmp(startTag + 1, "CWMIN_BACKGROUND", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMIN_DEFAULT;
gDefaultQosValues[BACKGROUND_QUEUE_INDEX].cwMin = value;
CWDebugLog("CWMIN_BACKGROUND: %d", gDefaultQosValues[BACKGROUND_QUEUE_INDEX].cwMin);
continue;
}
if (!strncmp(startTag + 1, "CWMAX_BACKGROUND", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = CWMAX_DEFAULT;
gDefaultQosValues[BACKGROUND_QUEUE_INDEX].cwMax = value;
CWDebugLog("CWMAX_BACKGROUND: %d", gDefaultQosValues[BACKGROUND_QUEUE_INDEX].cwMax);
continue;
}
if (!strncmp(startTag + 1, "AIFS_BACKGROUND", endTag - startTag - 1)) {
int value = atoi(endTag + 1);
if (value == 0)
value = AIFS_DEFAULT;
gDefaultQosValues[BACKGROUND_QUEUE_INDEX].AIFS = value;
CWDebugLog("AIFS_BACKGROUND: %d", gDefaultQosValues[BACKGROUND_QUEUE_INDEX].AIFS);
continue;
}
if (!strncmp(startTag + 1, "AC_HOSTAPD_PORT", endTag - startTag - 1)) {
gHostapd_port = atoi(endTag + 1);
CWDebugLog("Hostapd Port connection: %d", gHostapd_port);
continue;
}
if (!strncmp(startTag + 1, "AC_HOSTAPD_UNIX_PATH", endTag - startTag - 1)) {
char *startValue = NULL;
char *endValue = NULL;
int offset = 0;
CWExtractValue(endTag, &startValue, &endValue, &offset);
if (!((gHostapd_unix_path = ralloc_strndup(NULL, startValue, offset))))
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL);
CWDebugLog("Hostapd Unix Domain Path: %s", gHostapd_unix_path);
continue;
}
}
return CW_TRUE;
}
