function_name
stringlengths 1
80
| function
stringlengths 14
10.6k
| comment
stringlengths 12
8.02k
| normalized_comment
stringlengths 6
6.55k
|
|---|---|---|---|
CheckDeadLockThread
|
void CheckDeadLockThread(THREAD *t, void *param)
{
DEADCHECK *c = (DEADCHECK *)param;
if (t == NULL || c == NULL)
{
return;
}
NoticeThreadInit(t);
Lock(c->Lock);
Unlock(c->Lock);
c->Unlocked = true;
}
|
/* Thread to try to lock*/
|
Thread to try to lock
|
NewLockMain
|
LOCK *NewLockMain()
{
LOCK *lock;
UINT retry = 0;
while (true)
{
if ((retry++) > OBJECT_ALLOC__MAX_RETRY)
{
AbortExitEx("error: OSNewLock() failed.\n\n");
}
lock = OSNewLock();
if (lock != NULL)
{
break;
}
SleepThread(OBJECT_ALLOC_FAIL_SLEEP_TIME);
}
return lock;
}
|
/* Create a lock object*/
|
Create a lock object
|
DeleteLock
|
void DeleteLock(LOCK *lock)
{
// Validate arguments
if (lock == NULL)
{
return;
}
// KS
KS_INC(KS_DELETELOCK_COUNT);
KS_DEC(KS_CURRENT_LOCK_COUNT);
OSDeleteLock(lock);
}
|
/* Delete the lock object*/
|
Delete the lock object
|
NewCounter
|
COUNTER *NewCounter()
{
COUNTER *c;
// Memory allocation
c = Malloc(sizeof(COUNTER));
// Initialization
c->Ready = true;
c->c = 0;
// Lock created
c->lock = NewLock();
// KS
KS_INC(KS_NEW_COUNTER_COUNT);
return c;
}
|
/* Creating a counter*/
|
Creating a counter
|
DeleteCounter
|
void DeleteCounter(COUNTER *c)
{
// Validate arguments
if (c == NULL)
{
return;
}
// KS
KS_INC(KS_DELETE_COUNTER_COUNT);
KS_SUB(KS_CURRENT_COUNT, c->c);
DeleteLock(c->lock);
Free(c);
}
|
/* Delete the counter*/
|
Delete the counter
|
Count
|
UINT Count(COUNTER *c)
{
UINT ret;
// Validate arguments
if (c == NULL)
{
return 0;
}
if (c->Ready == false)
{
return 0;
}
Lock(c->lock);
{
ret = c->c;
}
Unlock(c->lock);
return ret;
}
|
/* Get the count value*/
|
Get the count value
|
Release
|
UINT Release(REF *ref)
{
UINT c;
// Validate arguments
if (ref == NULL)
{
return 0;
}
// KS
KS_INC(KS_RELEASE_COUNT);
KS_DEC(KS_CURRENT_REFED_COUNT);
c = Dec(ref->c);
if (c == 0)
{
// KS
KS_DEC(KS_CURRENT_REF_COUNT);
KS_INC(KS_FREEREF_COUNT);
DeleteCounter(ref->c);
ref->c = 0;
Free(ref);
}
return c;
}
|
/* Release of the reference counter*/
|
Release of the reference counter
|
AddRef
|
UINT AddRef(REF *ref)
{
UINT c;
// Validate arguments
if (ref == NULL)
{
return 0;
}
c = Inc(ref->c);
// KS
KS_INC(KS_ADDREF_COUNT);
KS_INC(KS_CURRENT_REFED_COUNT);
return c;
}
|
/* Increase of the reference counter*/
|
Increase of the reference counter
|
NewRef
|
REF *NewRef()
{
REF *ref;
// Memory allocation
ref = Malloc(sizeof(REF));
// Create a Counter
ref->c = NewCounter();
// Increment only once
Inc(ref->c);
// KS
KS_INC(KS_NEWREF_COUNT);
KS_INC(KS_CURRENT_REF_COUNT);
KS_INC(KS_ADDREF_COUNT);
KS_INC(KS_CURRENT_REFED_COUNT);
return ref;
}
|
/* Create a reference counter*/
|
Create a reference counter
|
NewEvent
|
EVENT *NewEvent()
{
// Memory allocation
EVENT *e = Malloc(sizeof(EVENT));
// Reference counter
e->ref = NewRef();
// Event initialization
OSInitEvent(e);
// KS
KS_INC(KS_NEWEVENT_COUNT);
return e;
}
|
/* Creating an event object*/
|
Creating an event object
|
ReleaseEvent
|
void ReleaseEvent(EVENT *e)
{
// Validate arguments
if (e == NULL)
{
return;
}
if (Release(e->ref) == 0)
{
CleanupEvent(e);
}
}
|
/* Release of the event*/
|
Release of the event
|
CleanupEvent
|
void CleanupEvent(EVENT *e)
{
// Validate arguments
if (e == NULL)
{
return;
}
// Release event
OSFreeEvent(e);
// Memory release
Free(e);
// KS
KS_INC(KS_FREEEVENT_COUNT);
}
|
/* Delete the event*/
|
Delete the event
|
Wait
|
bool Wait(EVENT *e, UINT timeout)
{
// Validate arguments
if (e == NULL)
{
return false;
}
// KS
KS_INC(KS_WAIT_COUNT);
return OSWaitEvent(e, timeout);
}
|
/* Wait for event*/
|
Wait for event
|
GetMimeTypeFromFileName
|
char *GetMimeTypeFromFileName(char *filename)
{
UINT i;
const UINT num = sizeof(http_mime_types) / sizeof(HTTP_MIME_TYPE);
if (filename == NULL)
{
return NULL;
}
for (i = 0; i < num; ++i)
{
const HTTP_MIME_TYPE *a = &http_mime_types[i];
if (EndWith(filename, a->Extension))
{
return a->MimeType;
}
}
return NULL;
}
|
/* Detect HTTP MIME type from filename*/
|
Detect HTTP MIME type from filename
|
ReplaceUnsafeCharInHttpTarget
|
void ReplaceUnsafeCharInHttpTarget(char *target)
{
UINT i;
for(i = 0; target[i] ; i++) {
if(target[i] == '<')
target[i] = '(';
else if(target[i] == '>')
target[i] = ')';
}
}
|
/* Replace unsafe characters in target*/
|
Replace unsafe characters in target
|
NewHttpHeader
|
HTTP_HEADER *NewHttpHeader(char *method, char *target, char *version)
{
return NewHttpHeaderEx(method, target, version, false);
}
|
/* Create an HTTP header*/
|
Create an HTTP header
|
FreeHttpHeader
|
void FreeHttpHeader(HTTP_HEADER *header)
{
UINT i;
HTTP_VALUE **values;
// Validate arguments
if (header == NULL)
{
return;
}
Free(header->Method);
Free(header->Target);
Free(header->Version);
values = ToArray(header->ValueList);
for (i = 0;i < LIST_NUM(header->ValueList);i++)
{
FreeHttpValue(values[i]);
}
Free(values);
ReleaseList(header->ValueList);
Free(header);
}
|
/* Release the HTTP header*/
|
Release the HTTP header
|
NewHttpValue
|
HTTP_VALUE *NewHttpValue(char *name, char *data)
{
HTTP_VALUE *v;
// Validate arguments
if (name == NULL || data == NULL)
{
return NULL;
}
v = ZeroMalloc(sizeof(HTTP_VALUE));
v->Name = CopyStr(name);
v->Data = CopyStr(data);
Trim(v->Name);
Trim(v->Data);
return v;
}
|
/* Create a new HTTP value*/
|
Create a new HTTP value
|
FreeHttpValue
|
void FreeHttpValue(HTTP_VALUE *value)
{
// Validate arguments
if (value == NULL)
{
return;
}
Free(value->Data);
Free(value->Name);
Free(value);
}
|
/* Release the HTTP value*/
|
Release the HTTP value
|
CompareHttpValue
|
int CompareHttpValue(void *p1, void *p2)
{
HTTP_VALUE *v1, *v2;
if (p1 == NULL || p2 == NULL)
{
return 0;
}
v1 = *(HTTP_VALUE **)p1;
v2 = *(HTTP_VALUE **)p2;
if (v1 == NULL || v2 == NULL)
{
return 0;
}
return StrCmpi(v1->Name, v2->Name);
}
|
/* Comparison function of the HTTP value*/
|
Comparison function of the HTTP value
|
GetHttpValue
|
HTTP_VALUE *GetHttpValue(HTTP_HEADER *header, char *name)
{
HTTP_VALUE *v, t;
// Validate arguments
if (header == NULL || name == NULL)
{
return NULL;
}
t.Name = name;
v = Search(header->ValueList, &t);
if (v == NULL)
{
return NULL;
}
return v;
}
|
/* Look for an HTTP value in an HTTP header*/
|
Look for an HTTP value in an HTTP header
|
AddHttpValue
|
void AddHttpValue(HTTP_HEADER *header, HTTP_VALUE *value)
{
// Validate arguments
if (header == NULL || value == NULL)
{
return;
}
if (LIST_NUM(header->ValueList) < HTTP_HEADER_MAX_LINES)
{
Insert(header->ValueList, value);
}
else
{
FreeHttpValue(value);
}
}
|
/* Add an HTTP value to the HTTP header*/
|
Add an HTTP value to the HTTP header
|
GetContentLength
|
UINT GetContentLength(HTTP_HEADER *header)
{
UINT ret;
HTTP_VALUE *v;
// Validate arguments
if (header == NULL)
{
return 0;
}
v = GetHttpValue(header, "Content-Length");
if (v == NULL)
{
return 0;
}
ret = ToInt(v->Data);
return ret;
}
|
/* Get the Content-Length value from the HTTP header*/
|
Get the Content-Length value from the HTTP header
|
SendHttpHeader
|
bool SendHttpHeader(SOCK *s, HTTP_HEADER *header)
{
char *str;
bool ret;
// Validate arguments
if (s == NULL || header == NULL)
{
return false;
}
// Convert to string
str = HttpHeaderToStr(header);
// Transmission
ret = SendAll(s, str, StrLen(str), s->SecureMode);
Free(str);
return ret;
}
|
/* Send the HTTP header*/
|
Send the HTTP header
|
HttpServerRecv
|
PACK *HttpServerRecv(SOCK *s)
{
return HttpServerRecvEx(s, 0);
}
|
/* Receive a PACK from the client*/
|
Receive a PACK from the client
|
ClearUniStr
|
void ClearUniStr(wchar_t *str, UINT str_size)
{
UniStrCpy(str, str_size, L"");
}
|
/* Initialize the string*/
|
Initialize the string
|
UniInChar
|
bool UniInChar(wchar_t *string, wchar_t c)
{
UINT i, len;
// Validate arguments
if (string == NULL)
{
return false;
}
len = UniStrLen(string);
for (i = 0;i < len;i++)
{
if (string[i] == c)
{
return true;
}
}
return false;
}
|
/* Examine whether the string contains the specified character*/
|
Examine whether the string contains the specified character
|
UniInStr
|
bool UniInStr(wchar_t *str, wchar_t *keyword)
{
return UniInStrEx(str, keyword, false);
}
|
/* Check whether the string is included*/
|
Check whether the string is included
|
UniStrToBin
|
BUF *UniStrToBin(wchar_t *str)
{
char *str_a = CopyUniToStr(str);
BUF *ret;
ret = StrToBin(str_a);
Free(str_a);
return ret;
}
|
/* Convert to binary data*/
|
Convert to binary data
|
UniIsSafeChar
|
bool UniIsSafeChar(wchar_t c)
{
UINT i, len;
wchar_t *check_str =
L"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
L"abcdefghijklmnopqrstuvwxyz"
L"0123456789"
L" ()-_#%&.";
len = UniStrLen(check_str);
for (i = 0;i < len;i++)
{
if (c == check_str[i])
{
return true;
}
}
return false;
}
|
/* Check whether the character is safe*/
|
Check whether the character is safe
|
UniListToTokenList
|
UNI_TOKEN_LIST *UniListToTokenList(LIST *o)
{
UINT i;
UNI_TOKEN_LIST *t;
// Validate arguments
if (o == NULL)
{
return NULL;
}
t = ZeroMalloc(sizeof(UNI_TOKEN_LIST));
t->NumTokens = LIST_NUM(o);
t->Token = ZeroMalloc(sizeof(wchar_t *) * t->NumTokens);
for (i = 0;i < LIST_NUM(o);i++)
{
t->Token[i] = UniCopyStr(LIST_DATA(o, i));
}
return t;
}
|
/* Convert a string list to a token list*/
|
Convert a string list to a token list
|
UniFreeStrList
|
void UniFreeStrList(LIST *o)
{
UINT i;
// Validate arguments
if (o == NULL)
{
return;
}
for (i = 0;i < LIST_NUM(o);i++)
{
wchar_t *s = LIST_DATA(o, i);
Free(s);
}
ReleaseList(o);
}
|
/* Free the string list*/
|
Free the string list
|
UniEndWith
|
bool UniEndWith(wchar_t *str, wchar_t *key)
{
UINT str_len;
UINT key_len;
// Validate arguments
if (str == NULL || key == NULL)
{
return false;
}
// Comparison
str_len = UniStrLen(str);
key_len = UniStrLen(key);
if (str_len < key_len)
{
return false;
}
if (UniStrCmpi(str + (str_len - key_len), key) == 0)
{
return true;
}
else
{
return false;
}
}
|
/* Check whether str ends with the key*/
|
Check whether str ends with the key
|
UniStartWith
|
bool UniStartWith(wchar_t *str, wchar_t *key)
{
UINT str_len;
UINT key_len;
wchar_t *tmp;
bool ret;
// Validate arguments
if (str == NULL || key == NULL)
{
return false;
}
// Comparison
str_len = UniStrLen(str);
key_len = UniStrLen(key);
if (str_len < key_len)
{
return false;
}
if (str_len == 0 || key_len == 0)
{
return false;
}
tmp = CopyUniStr(str);
tmp[key_len] = 0;
if (UniStrCmpi(tmp, key) == 0)
{
ret = true;
}
else
{
ret = false;
}
Free(tmp);
return ret;
}
|
/* Check whether str starts with the key*/
|
Check whether str starts with the key
|
UniToStr3
|
void UniToStr3(wchar_t *str, UINT size, UINT64 value)
{
char tmp[MAX_SIZE];
// Validate arguments
if (str == NULL)
{
return;
}
ToStr3(tmp, sizeof(tmp), value);
StrToUni(str, size, tmp);
}
|
/* Convert the integer to a comma-separated string*/
|
Convert the integer to a comma-separated string
|
UniStrWidth
|
UINT UniStrWidth(wchar_t *str)
{
UINT i, len, ret;
// Validate arguments
if (str == NULL)
{
return 0;
}
ret = 0;
len = UniStrLen(str);
for (i = 0;i < len;i++)
{
if (str[i] <= 255)
{
ret++;
}
else
{
ret += 2;
}
}
return ret;
}
|
/* Get the width of the string*/
|
Get the width of the string
|
Utf16ToWide
|
wchar_t *Utf16ToWide(USHORT *str)
{
wchar_t *ret;
UINT len, i;
// Validate arguments
if (str == NULL)
{
return NULL;
}
len = 0;
while (true)
{
if (str[len] == 0)
{
break;
}
len++;
}
ret = Malloc((len + 1) * sizeof(wchar_t));
for (i = 0;i < len + 1;i++)
{
ret[i] = (wchar_t)str[i];
}
return ret;
}
|
/* Convert string of 2 byte/character to wchar_t of 4 byte/character*/
|
Convert string of 2 byte/character to wchar_t of 4 byte/character
|
WideToUtf16
|
USHORT *WideToUtf16(wchar_t *str)
{
USHORT *ret;
UINT len;
UINT ret_size;
UINT i;
// Validate arguments
if (str == NULL)
{
return NULL;
}
len = UniStrLen(str);
ret_size = (len + 1) * 2;
ret = Malloc(ret_size);
for (i = 0;i < len + 1;i++)
{
ret[i] = (USHORT)str[i];
}
return ret;
}
|
/* Convert wchar_t string of 4 byte/character to string of 2 byte/character*/
|
Convert wchar_t string of 4 byte/character to string of 2 byte/character
|
FreeInternational
|
void FreeInternational()
{
#ifdef OS_UNIX
#endif // OS_UNIX
}
|
/* Release of the International Library*/
|
Release of the International Library
|
UnixCalcStrToUni
|
UINT UnixCalcStrToUni(char *str)
{
wchar_t *tmp;
UINT len, tmp_size;
UINT ret;
// Validate arguments
if (str == NULL)
{
return 0;
}
len = StrLen(str);
tmp_size = len * 5 + 10;
tmp = ZeroMalloc(tmp_size);
UnixStrToUni(tmp, tmp_size, str);
ret = UniStrLen(tmp);
Free(tmp);
return (ret + 1) * sizeof(wchar_t);
}
|
/* Calculate the size when the string converted to Unicode*/
|
Calculate the size when the string converted to Unicode
|
UnixCalcUniToStr
|
UINT UnixCalcUniToStr(wchar_t *s)
{
char *tmp;
UINT tmp_size;
UINT ret;
// Validate arguments
if (s == NULL)
{
return 0;
}
tmp_size = UniStrLen(s) * 5 + 10;
tmp = ZeroMalloc(tmp_size);
UnixUniToStr(tmp, tmp_size, s);
ret = StrSize(tmp);
Free(tmp);
return ret;
}
|
/* Calculate the size when the Unicode converted to string*/
|
Calculate the size when the Unicode converted to string
|
IconvWideToStrInternal
|
void *IconvWideToStrInternal()
{
return (void *)iconv_open(charset, IsBigEndian() ? "UTF-16BE" : "UTF-16LE");
}
|
/* Converted the whcar_t to char*/
|
Converted the whcar_t to char
|
IconvStrToWideInternal
|
void *IconvStrToWideInternal()
{
return (void *)iconv_open(IsBigEndian() ? "UTF-16BE" : "UTF-16LE", charset);
}
|
/* Convert the char to a wchar_t*/
|
Convert the char to a wchar_t
|
IconvFreeInternal
|
int IconvFreeInternal(void *d)
{
iconv_close((iconv_t)d);
return 0;
}
|
/* Close the handle*/
|
Close the handle
|
UniIsEmptyStr
|
bool UniIsEmptyStr(wchar_t *str)
{
return IsEmptyUniStr(str);
}
|
/* Check whether the specified string is a space*/
|
Check whether the specified string is a space
|
UniIsNum
|
bool UniIsNum(wchar_t *str)
{
char tmp[MAX_SIZE];
// Validate arguments
if (str == NULL)
{
return false;
}
UniToStrForSingleChars(tmp, sizeof(tmp), str);
return IsNum(tmp);
}
|
/* Check whether the specified string is a number*/
|
Check whether the specified string is a number
|
UniNullToken
|
UNI_TOKEN_LIST *UniNullToken()
{
UNI_TOKEN_LIST *ret = ZeroMalloc(sizeof(UNI_TOKEN_LIST));
ret->Token = ZeroMalloc(0);
return ret;
}
|
/* Empty Unicode token list*/
|
Empty Unicode token list
|
TokenListToUniTokenList
|
UNI_TOKEN_LIST *TokenListToUniTokenList(TOKEN_LIST *src)
{
UNI_TOKEN_LIST *ret;
UINT i;
// Validate arguments
if (src == NULL)
{
return NULL;
}
ret = ZeroMalloc(sizeof(UNI_TOKEN_LIST));
ret->NumTokens = src->NumTokens;
ret->Token = ZeroMalloc(sizeof(wchar_t *) * ret->NumTokens);
for (i = 0;i < ret->NumTokens;i++)
{
ret->Token[i] = CopyStrToUni(src->Token[i]);
}
return ret;
}
|
/* Convert the token list to Unicode token list*/
|
Convert the token list to Unicode token list
|
UniTokenListToTokenList
|
TOKEN_LIST *UniTokenListToTokenList(UNI_TOKEN_LIST *src)
{
TOKEN_LIST *ret;
UINT i;
// Validate arguments
if (src == NULL)
{
return NULL;
}
ret = ZeroMalloc(sizeof(TOKEN_LIST));
ret->NumTokens = src->NumTokens;
ret->Token = ZeroMalloc(sizeof(char *) * ret->NumTokens);
for (i = 0;i < ret->NumTokens;i++)
{
ret->Token[i] = CopyUniToStr(src->Token[i]);
}
return ret;
}
|
/* Convert a Unicode token list to a token list*/
|
Convert a Unicode token list to a token list
|
UniCopyStr
|
wchar_t *UniCopyStr(wchar_t *str)
{
return CopyUniStr(str);
}
|
/* Unicode string copy*/
|
Unicode string copy
|
UniCopyToken
|
UNI_TOKEN_LIST *UniCopyToken(UNI_TOKEN_LIST *src)
{
UNI_TOKEN_LIST *ret;
UINT i;
// Validate arguments
if (src == NULL)
{
return NULL;
}
ret = ZeroMalloc(sizeof(TOKEN_LIST));
ret->NumTokens = src->NumTokens;
ret->Token = ZeroMalloc(sizeof(wchar_t *) * ret->NumTokens);
for (i = 0;i < ret->NumTokens;i++)
{
ret->Token[i] = CopyUniStr(src->Token[i]);
}
return ret;
}
|
/* Copy the token list*/
|
Copy the token list
|
UniToInt64
|
UINT64 UniToInt64(wchar_t *str)
{
char tmp[MAX_SIZE];
// Validate arguments
if (str == NULL)
{
return 0;
}
UniToStrForSingleChars(tmp, sizeof(tmp), str);
return ToInt64(tmp);
}
|
/* Convert Unicode string to 64bit integer*/
|
Convert Unicode string to 64bit integer
|
UtfToUni
|
UINT UtfToUni(wchar_t *unistr, UINT size, char *utfstr)
{
wchar_t *tmp;
// Validate arguments
if (unistr == NULL || utfstr == NULL)
{
UniStrCpy(unistr, size, L"");
return 0;
}
tmp = CopyUtfToUni(utfstr);
UniStrCpy(unistr, size, tmp);
Free(tmp);
return UniStrLen(unistr);
}
|
/* Convert the UTF string to a Unicode string*/
|
Convert the UTF string to a Unicode string
|
CopyUtfToUni
|
wchar_t *CopyUtfToUni(char *utfstr)
{
UINT size;
wchar_t *ret;
UINT utfstr_len;
// Validate arguments
if (utfstr == NULL)
{
return NULL;
}
utfstr_len = StrLen(utfstr);
size = CalcUtf8ToUni((BYTE *)utfstr, utfstr_len);
ret = ZeroMalloc(size + sizeof(wchar_t));
Utf8ToUni(ret, size, (BYTE *)utfstr, utfstr_len);
return ret;
}
|
/* Copy the UTF-8 string to a Unicode string*/
|
Copy the UTF-8 string to a Unicode string
|
CopyUniToStr
|
char *CopyUniToStr(wchar_t *unistr)
{
char *str;
UINT str_size;
// Validate arguments
if (unistr == NULL)
{
return NULL;
}
str_size = CalcUniToStr(unistr);
if (str_size == 0)
{
return CopyStr("");
}
str = Malloc(str_size);
UniToStr(str, str_size, unistr);
return str;
}
|
/* Copy a Unicode string to ANSI string*/
|
Copy a Unicode string to ANSI string
|
CopyStrToUni
|
wchar_t *CopyStrToUni(char *str)
{
wchar_t *uni;
UINT uni_size;
// Validate arguments
if (str == NULL)
{
return NULL;
}
uni_size = CalcStrToUni(str);
if (uni_size == 0)
{
return CopyUniStr(L"");
}
uni = Malloc(uni_size);
StrToUni(uni, uni_size, str);
return uni;
}
|
/* Copy an ANSI string to a Unicode string*/
|
Copy an ANSI string to a Unicode string
|
CopyUniToUtf
|
char *CopyUniToUtf(wchar_t *unistr)
{
UINT size;
char *ret;
// Validate arguments
if (unistr == NULL)
{
return NULL;
}
size = CalcUniToUtf8(unistr);
ret = ZeroMalloc(size + sizeof(char));
UniToUtf8((char *)ret, size, unistr);
return ret;
}
|
/* Copy a Unicode string to UTF-8 string*/
|
Copy a Unicode string to UTF-8 string
|
CopyUniStr
|
wchar_t *CopyUniStr(wchar_t *str)
{
UINT len;
wchar_t *dst;
// Validate arguments
if (str == NULL)
{
return NULL;
}
len = UniStrLen(str);
dst = Malloc((len + 1) * sizeof(wchar_t));
UniStrCpy(dst, 0, str);
return dst;
}
|
/* Copy the Unicode string*/
|
Copy the Unicode string
|
IsSafeUniStr
|
bool IsSafeUniStr(wchar_t *str)
{
UINT i, len;
// Validate arguments
if (str == NULL)
{
return false;
}
len = UniStrLen(str);
for (i = 0;i < len;i++)
{
if (IsSafeUniChar(str[i]) == false)
{
return false;
}
}
if (str[0] == L' ')
{
return false;
}
if (len != 0)
{
if (str[len - 1] == L' ')
{
return false;
}
}
return true;
}
|
/* Check whether the string is safe*/
|
Check whether the string is safe
|
IsSafeUniChar
|
bool IsSafeUniChar(wchar_t c)
{
UINT i, len;
wchar_t *check_str =
L"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
L"abcdefghijklmnopqrstuvwxyz"
L"0123456789"
L" ()-_#%&.";
len = UniStrLen(check_str);
for (i = 0;i < len;i++)
{
if (c == check_str[i])
{
return true;
}
}
return false;
}
|
/* Check whether the character is safe*/
|
Check whether the character is safe
|
UniToStr
|
UINT UniToStr(char *str, UINT size, wchar_t *s)
{
#ifdef OS_WIN32
UINT ret;
char *tmp;
UINT new_size;
// Validate arguments
if (s == NULL || str == NULL)
{
return 0;
}
new_size = CalcUniToStr(s);
if (new_size == 0)
{
if (size >= 1)
{
StrCpy(str, 0, "");
}
return 0;
}
tmp = Malloc(new_size);
tmp[0] = 0;
wcstombs(tmp, s, new_size);
tmp[new_size - 1] = 0;
ret = StrCpy(str, size, tmp);
Free(tmp);
return ret;
#else // OS_WIN32
return UnixUniToStr(str, size, s);
#endif // OS_WIN32
}
|
/* Convert Unicode string to ANSI string*/
|
Convert Unicode string to ANSI string
|
CalcUniToStr
|
UINT CalcUniToStr(wchar_t *s)
{
#ifdef OS_WIN32
UINT ret;
// Validate arguments
if (s == NULL)
{
return 0;
}
ret = (UINT)wcstombs(NULL, s, UniStrLen(s));
if (ret == (UINT)-1)
{
return 0;
}
return ret + 1;
#else // OS_WIN32
return UnixCalcUniToStr(s);
#endif // OS_WIN32
}
|
/* Get the required number of bytes to convert Unicode string to the ANSI string*/
|
Get the required number of bytes to convert Unicode string to the ANSI string
|
CalcStrToUni
|
UINT CalcStrToUni(char *str)
{
#ifdef OS_WIN32
UINT ret;
// Validate arguments
if (str == NULL)
{
return 0;
}
ret = (UINT)mbstowcs(NULL, str, StrLen(str));
if (ret == (UINT)-1)
{
return 0;
}
return (ret + 1) * sizeof(wchar_t);
#else // OS_WIN32
return UnixCalcStrToUni(str);
#endif // OS_WIN32
}
|
/* Get the required buffer size for converting an ANSI string to an Unicode string*/
|
Get the required buffer size for converting an ANSI string to an Unicode string
|
CalcUtf8ToUni
|
UINT CalcUtf8ToUni(BYTE *u, UINT u_size)
{
// Validate arguments
if (u == NULL)
{
return 0;
}
if (u_size == 0)
{
u_size = StrLen((char *)u);
}
return (Utf8Len(u, u_size) + 1) * sizeof(wchar_t);
}
|
/* Get the buffer size when converted UTF-8 to Unicode*/
|
Get the buffer size when converted UTF-8 to Unicode
|
Utf8Len
|
UINT Utf8Len(BYTE *u, UINT size)
{
UINT i, num;
// Validate arguments
if (u == NULL)
{
return 0;
}
if (size == 0)
{
size = StrLen((char *)u);
}
i = num = 0;
while (true)
{
UINT type;
type = GetUtf8Type(u, size, i);
if (type == 0)
{
break;
}
i += type;
num++;
}
return num;
}
|
/* Get the number of characters in UTF-8 string*/
|
Get the number of characters in UTF-8 string
|
CalcUniToUtf8
|
UINT CalcUniToUtf8(wchar_t *s)
{
UINT i, len, size;
// Validate arguments
if (s == NULL)
{
return 0;
}
size = 0;
len = UniStrLen(s);
for (i = 0;i < len;i++)
{
size += GetUniType(s[i]);
}
return size;
}
|
/* Calculating the length of the string when converting Unicode string to UTF-8 string*/
|
Calculating the length of the string when converting Unicode string to UTF-8 string
|
UniReplaceStr
|
UINT UniReplaceStr(wchar_t *dst, UINT size, wchar_t *string, wchar_t *old_keyword, wchar_t *new_keyword)
{
return UniReplaceStrEx(dst, size, string, old_keyword, new_keyword, true);
}
|
/* String replacing (case-sensitive)*/
|
String replacing (case-sensitive)
|
UniSearchStr
|
UINT UniSearchStr(wchar_t *string, wchar_t *keyword, UINT start)
{
return UniSearchStrEx(string, keyword, start, true);
}
|
/* Search for a string (distinguish between upper / lower case)*/
|
Search for a string (distinguish between upper / lower case)
|
UniFreeToken
|
void UniFreeToken(UNI_TOKEN_LIST *tokens)
{
UINT i;
if (tokens == NULL)
{
return;
}
for (i = 0;i < tokens->NumTokens;i++)
{
Free(tokens->Token[i]);
}
Free(tokens->Token);
Free(tokens);
}
|
/* Release of the token list*/
|
Release of the token list
|
UnixUniParseToken
|
UNI_TOKEN_LIST *UnixUniParseToken(wchar_t *src, wchar_t *separator)
{
UNI_TOKEN_LIST *ret;
TOKEN_LIST *t;
char *src_s;
char *sep_s;
// Validate arguments
if (src == NULL || separator == NULL)
{
ret = ZeroMalloc(sizeof(UNI_TOKEN_LIST));
ret->Token = ZeroMalloc(0);
return ret;
}
src_s = CopyUniToStr(src);
sep_s = CopyUniToStr(separator);
t = ParseToken(src_s, sep_s);
ret = TokenListToUniTokenList(t);
FreeToken(t);
Free(src_s);
Free(sep_s);
return ret;
}
|
/* Parse token for UNIX*/
|
Parse token for UNIX
|
UniGetLine
|
bool UniGetLine(wchar_t *str, UINT size)
{
#ifdef OS_WIN32
return UniGetLineWin32(str, size);
#else // OS_WIN32
return UniGetLineUnix(str, size);
#endif // OS_WIN32
}
|
/* Get a line from standard input*/
|
Get a line from standard input
|
UniTrimCrlf
|
void UniTrimCrlf(wchar_t *str)
{
UINT len;
// Validate arguments
if (str == NULL)
{
return;
}
len = UniStrLen(str);
if (len == 0)
{
return;
}
if (str[len - 1] == L'\n')
{
if (len >= 2 && str[len - 2] == L'\r')
{
str[len - 2] = 0;
}
str[len - 1] = 0;
}
else if(str[len - 1] == L'\r')
{
str[len - 1] = 0;
}
}
|
/* Remove '\r\n' at the end*/
|
Remove ' ' at the end
|
UniTrim
|
void UniTrim(wchar_t *str)
{
// Validate arguments
if (str == NULL)
{
return;
}
UniTrimLeft(str);
UniTrimRight(str);
}
|
/* Remove white space of the both side of the string*/
|
Remove white space of the both side of the string
|
UniToStri
|
void UniToStri(wchar_t *str, int i)
{
UniFormat(str, 0, L"%i", i);
}
|
/* Convert a signed integer to a string*/
|
Convert a signed integer to a string
|
UniToStru
|
void UniToStru(wchar_t *str, UINT i)
{
UniFormat(str, 0, L"%u", i);
}
|
/* Convert an integer to a string*/
|
Convert an integer to a string
|
UniToInt
|
UINT UniToInt(wchar_t *str)
{
char tmp[128];
// Validate arguments
if (str == NULL)
{
return 0;
}
UniToStrForSingleChars(tmp, sizeof(tmp), str);
return ToInti(tmp);
}
|
/* Convert a string to an integer*/
|
Convert a string to an integer
|
UniToStrForSingleChars
|
void UniToStrForSingleChars(char *dst, UINT dst_size, wchar_t *src)
{
UINT i;
// Validate arguments
if (dst == NULL || src == NULL)
{
return;
}
for (i = 0;i < UniStrLen(src) + 1;i++)
{
wchar_t s = src[i];
char d;
if (s == 0)
{
d = 0;
}
else if (s <= 0xff)
{
d = (char)s;
}
else
{
d = ' ';
}
dst[i] = d;
}
}
|
/* Convert only single-byte characters in the Unicode string to a char string*/
|
Convert only single-byte characters in the Unicode string to a char string
|
UniPrintStr
|
void UniPrintStr(wchar_t *string)
{
// Validate arguments
if (string == NULL)
{
return;
}
#ifdef OS_UNIX
if (true)
{
char *str = CopyUniToStr(string);
if (str != NULL)
{
fputs(str, stdout);
}
else
{
fputs("", stdout);
}
Free(str);
}
#else // OS_UNIX
Win32PrintW(string);
#endif // OS_UNIX
}
|
/* Display the string on the screen*/
|
Display the string on the screen
|
UniPrintArgs
|
void UniPrintArgs(wchar_t *fmt, va_list args)
{
wchar_t *str;
// Validate arguments
if (fmt == NULL)
{
return;
}
str = InternalFormatArgs(fmt, args, false);
UniPrintStr(str);
Free(str);
}
|
/* Display a string with arguments*/
|
Display a string with arguments
|
UniPrint
|
void UniPrint(wchar_t *fmt, ...)
{
va_list args;
// Validate arguments
if (fmt == NULL)
{
return;
}
va_start(args, fmt);
UniPrintArgs(fmt, args);
va_end(args);
}
|
/* Display the string*/
|
Display the string
|
UniDebugArgs
|
void UniDebugArgs(wchar_t *fmt, va_list args)
{
if (g_debug == false)
{
return;
}
UniPrintArgs(fmt, args);
}
|
/* Display debug string with arguments*/
|
Display debug string with arguments
|
UniDebug
|
void UniDebug(wchar_t *fmt, ...)
{
va_list args;
// Validate arguments
if (fmt == NULL)
{
return;
}
va_start(args, fmt);
UniDebugArgs(fmt, args);
va_end(args);
}
|
/* Display a debug string*/
|
Display a debug string
|
UniFormatArgs
|
void UniFormatArgs(wchar_t *buf, UINT size, wchar_t *fmt, va_list args)
{
wchar_t *ret;
// Validate arguments
if (buf == NULL || fmt == NULL)
{
return;
}
if (size == 1)
{
return;
}
// KS
KS_INC(KS_FORMAT_COUNT);
ret = InternalFormatArgs(fmt, args, false);
UniStrCpy(buf, size, ret);
Free(ret);
}
|
/* Format a string (argument list)*/
|
Format a string (argument list)
|
CopyUniFormat
|
wchar_t *CopyUniFormat(wchar_t *fmt, ...)
{
wchar_t *ret, *str;
UINT size;
va_list args;
// Validate arguments
if (fmt == NULL)
{
return NULL;
}
size = MAX(UniStrSize(fmt) * 10, MAX_SIZE * 10);
str = Malloc(size);
va_start(args, fmt);
UniFormatArgs(str, size, fmt, args);
ret = UniCopyStr(str);
Free(str);
va_end(args);
return ret;
}
|
/* Format the string, and copy it*/
|
Format the string, and copy it
|
UniFormat
|
void UniFormat(wchar_t *buf, UINT size, wchar_t *fmt, ...)
{
va_list args;
// Validate arguments
if (buf == NULL || fmt == NULL)
{
return;
}
va_start(args, fmt);
UniFormatArgs(buf, size, fmt, args);
va_end(args);
}
|
/* Format the string*/
|
Format the string
|
UniSoftStrCmp
|
int UniSoftStrCmp(wchar_t *str1, wchar_t *str2)
{
UINT ret;
wchar_t *tmp1, *tmp2;
// Validate arguments
if (str1 == NULL && str2 == NULL)
{
return 0;
}
if (str1 == NULL)
{
return 1;
}
if (str2 == NULL)
{
return -1;
}
tmp1 = CopyUniStr(str1);
tmp2 = CopyUniStr(str2);
UniTrim(tmp1);
UniTrim(tmp2);
ret = UniStrCmpi(tmp1, tmp2);
Free(tmp1);
Free(tmp2);
return ret;
}
|
/* Flexible string comparison*/
|
Flexible string comparison
|
UniStrCmpi
|
int UniStrCmpi(wchar_t *str1, wchar_t *str2)
{
UINT i;
// Validate arguments
if (str1 == NULL && str2 == NULL)
{
return 0;
}
if (str1 == NULL)
{
return 1;
}
if (str2 == NULL)
{
return -1;
}
// String comparison
i = 0;
while (true)
{
wchar_t c1, c2;
c1 = UniToUpper(str1[i]);
c2 = UniToUpper(str2[i]);
if (c1 > c2)
{
return 1;
}
else if (c1 < c2)
{
return -1;
}
if (str1[i] == 0 || str2[i] == 0)
{
return 0;
}
i++;
}
}
|
/* Compare the strings in case-insensitive mode*/
|
Compare the strings in case-insensitive mode
|
UniStrCmp
|
int UniStrCmp(wchar_t *str1, wchar_t *str2)
{
// Validate arguments
if (str1 == NULL && str2 == NULL)
{
return 0;
}
if (str1 == NULL)
{
return 1;
}
if (str2 == NULL)
{
return -1;
}
return wcscmp(str1, str2);
}
|
/* Compare the string*/
|
Compare the string
|
UniStrLower
|
void UniStrLower(wchar_t *str)
{
UINT i, len;
// Validate arguments
if (str == NULL)
{
return;
}
len = UniStrLen(str);
for (i = 0;i < len;i++)
{
str[i] = UniToLower(str[i]);
}
}
|
/* Uncapitalize the string*/
|
Uncapitalize the string
|
UniStrUpper
|
void UniStrUpper(wchar_t *str)
{
UINT i, len;
// Validate arguments
if (str == NULL)
{
return;
}
len = UniStrLen(str);
for (i = 0;i < len;i++)
{
str[i] = UniToUpper(str[i]);
}
}
|
/* Capitalize the string*/
|
Capitalize the string
|
UniToLower
|
wchar_t UniToLower(wchar_t c)
{
if (c >= L'A' && c <= L'Z')
{
c += L'a' - L'A';
}
return c;
}
|
/* Uncapitalize a character*/
|
Uncapitalize a character
|
UniToUpper
|
wchar_t UniToUpper(wchar_t c)
{
if (c >= L'a' && c <= L'z')
{
c -= L'a' - L'A';
}
return c;
}
|
/* Capitalize a character*/
|
Capitalize a character
|
UniStrSize
|
UINT UniStrSize(wchar_t *str)
{
// Validate arguments
if (str == NULL)
{
return 0;
}
return (UniStrLen(str) + 1) * sizeof(wchar_t);
}
|
/* Get the buffer size needed to store the string*/
|
Get the buffer size needed to store the string
|
UniStrLen
|
UINT UniStrLen(wchar_t *str)
{
UINT i;
// Validate arguments
if (str == NULL)
{
return 0;
}
i = 0;
while (true)
{
if (str[i] == 0)
{
break;
}
i++;
}
return i;
}
|
/* Get the length of the string*/
|
Get the length of the string
|
IcmpFreeResult
|
void IcmpFreeResult(ICMP_RESULT *r)
{
// Validate arguments
if (r == NULL)
{
return;
}
IcmpApiFreeResult(r);
}
|
/* Release the memory for the ICMP response*/
|
Release the memory for the ICMP response
|
FreeDHCPv4Data
|
void FreeDHCPv4Data(DHCPV4_DATA *d)
{
// Validate arguments
if (d == NULL)
{
return;
}
FreeDhcpOptions(d->OptionList);
Free(d->Data);
Free(d->ParsedOptionList);
Free(d);
}
|
/* Release the DHCPv4 packet*/
|
Release the DHCPv4 packet
|
IPv6GetNextHeaderFromQueue
|
UCHAR IPv6GetNextHeaderFromQueue(QUEUE *q)
{
UINT *p;
UCHAR v = 0;
// Validate arguments
if (q == NULL)
{
return IPV6_HEADER_NONE;
}
p = (UINT *)GetNext(q);
if (p != NULL)
{
v = (UCHAR)(*p);
Free(p);
}
return v;
}
|
/* Get the next header number from the queue*/
|
Get the next header number from the queue
|
BuildAndAddIPv6PacketOptionHeader
|
void BuildAndAddIPv6PacketOptionHeader(BUF *b, IPV6_OPTION_HEADER *opt, UCHAR next_header, UINT size)
{
IPV6_OPTION_HEADER *h;
UINT total_size;
// Validate arguments
if (b == NULL || opt == NULL)
{
return;
}
total_size = size;
if ((total_size % 8) != 0)
{
total_size = ((total_size / 8) + 1) * 8;
}
h = ZeroMalloc(total_size);
Copy(h, opt, size);
h->Size = (total_size / 8) - 1;
h->NextHeader = next_header;
WriteBuf(b, h, total_size);
Free(h);
}
|
/* Add an IPv6 extension header option (variable length)*/
|
Add an IPv6 extension header option (variable length)
|
BuildICMPv6OptionValue
|
void BuildICMPv6OptionValue(BUF *b, UCHAR type, void *header_pointer, UINT total_size)
{
UINT packet_size;
UCHAR *packet;
ICMPV6_OPTION *opt;
// Validate arguments
if (b == NULL || header_pointer == NULL)
{
return;
}
packet_size = ((total_size + 7) / 8) * 8;
packet = ZeroMalloc(packet_size);
Copy(packet, header_pointer, total_size);
opt = (ICMPV6_OPTION *)packet;
opt->Length = (UCHAR)(packet_size / 8);
opt->Type = type;
WriteBuf(b, packet, packet_size);
Free(packet);
}
|
/* Build the option values of an ICMPv6 packet*/
|
Build the option values of an ICMPv6 packet
|
ParsePacket
|
PKT *ParsePacket(UCHAR *buf, UINT size)
{
return ParsePacketEx(buf, size, false);
}
|
/* Parse the contents of the packet*/
|
Parse the contents of the packet
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.