www.pudn.com > filespy.rar > unicode_str.c

#include "unicode_strdef.h" 
#include "unicode_str.h" 
#include  
#include  
#include  
 
// 
// CopyRight: Wanfustudio (C) 2007 
// Distribute: free use and copy ,modify 
// 
 
 
 
ULONG 
GetWideStrLen( 
  const WCHAR* str   
  ) 
//============================== 
// Get a NULL terminated unicode 
// string's length 
//==============================   
   
{ 
    ULONG len = 0; 
     
    if(NULL == str) 
    {     
        return 0; 
    } 
     
    while(*(str++) != L'\0') 
    {     
        ++len; 
    } 
     
    return len; 
} 
 
 
 
VOID 
CopyWideStr( 
  WCHAR* dst, 
  const WCHAR* src 
  ) 
//============================== 
// Copy a NULL terminated unicode 
// string to another one 
//==============================   
{ 
    if(NULL == dst || NULL == src) 
    {         
        return;     
    } 
     
    while( ( *(dst++)= *(src++) ) != L'\0' ) 
    {     
        ; // do nothing     
    } 
} 
 
 
 
PVOID 
AllocStrWithWideStr( 
  const WCHAR* str 
  ) 
//============================== 
// Allocate a String 
//  
//==============================   
{ 
     USTR_BLOCK *block = 
         (USTR_BLOCK *)ExAllocatePool(NonPagedPool, sizeof(USTR_BLOCK)); 
     WCHAR* buf = NULL; 
     WCHAR buflen = Max(wcslen(str) + WIDE_STR_APD_LEN, WIDE_STR_BUF_LEN); 
      
     if(NULL == block) 
     {          
         return NULL; 
     } 
      
     buf = ExAllocatePool(NonPagedPool, buflen * sizeof(WCHAR) ); 
      
     if( NULL == buf) 
     {      
         ExFreePool(block); 
         return NULL; 
     }  
      
     wcscpy(buf, str); 
     RtlInitUnicodeString(&block->ustr, buf); 
     block->buf = buf; 
     block->buflen = buflen; 
      
     return (PVOID)block; 
} 
 
 
 
 
 
PVOID 
AllocStrWithUniStr( 
  const PUNICODE_STRING ustr   
  ) 
//============================== 
// Allocate a string with  
// unicode string  
//==============================    
{ 
     USTR_BLOCK *block = 
         (USTR_BLOCK *)ExAllocatePool(NonPagedPool, sizeof(USTR_BLOCK)); 
     WCHAR* buf = NULL; 
     WCHAR buflen = Max(ustr->Length + WIDE_STR_APD_LEN, WIDE_STR_BUF_LEN); 
      
     if(NULL == block) 
     {          
         return NULL; 
     } 
      
     buf = ExAllocatePool(NonPagedPool, buflen * sizeof( WCHAR) ); 
      
     if( NULL == buf) 
     {      
         ExFreePool(block); 
         return NULL; 
     }  
      
     block->buf = buf; 
     block->buflen = buflen; 
     RtlInitEmptyUnicodeString(&block->ustr, block->buf, buflen * sizeof(WCHAR)); 
      
     RtlCopyUnicodeString(&block->ustr, ustr); 
     block->buf[ustr->Length] = L'\0'; 
      
     return (PVOID)block;      
} 
 
 
 
 
VOID 
FreeStr( 
  PVOID str 
  ) 
//============================== 
// Free String 's Buffer 
//  
//==============================    
{ 
    USTR_BLOCK *block = (USTR_BLOCK *)str; 
     
    if( NULL == str) 
    {     
        return; 
    }  
     
    if(block->buf) 
    {     
        ExFreePool(block->buf); 
    } 
     
    ExFreePool(block);     
} 
 
 
 
BOOLEAN 
SetStrWithWideStr( 
  PVOID str, 
  const WCHAR* content 
  ) 
//============================== 
// Set String With WideByte String 
// USTR_BLOCK TYPE 
//==============================    
{ 
    USTR_BLOCK *block = (USTR_BLOCK *)str; 
    WCHAR *buf = NULL; 
    ULONG buflen = GetWideStrLen(content) + WIDE_STR_APD_LEN; 
     
    if(block->buflen < buflen) 
    {     
        buf = ExAllocatePool(NonPagedPool, buflen * sizeof(WCHAR) ); 
         
        if(NULL == buf) 
        {             
            return FALSE; 
        } 
         
        if(block->buf) 
        {         
            ExFreePool(block->buf); 
            block->buf = NULL; 
        } 
         
        block->buf = buf; 
        block->buflen = buflen; 
    } 
     
    RtlZeroMemory(&block->ustr, sizeof(block->ustr) ); 
    wcscpy(block->buf, content); 
     
    RtlInitUnicodeString(&block->ustr, block->buf); 
     
    return TRUE; 
} 
 
 
 
 
BOOLEAN 
SetStrWithUniStr( 
  PVOID str, 
  const PUNICODE_STRING content 
  ) 
//============================== 
// Set String With Unicode String  
// USTR_BLOCK TYPE 
//==============================     
{ 
    USTR_BLOCK *block = (USTR_BLOCK*)str; 
    WCHAR* buf = NULL; 
    ULONG buflen = content->Length + WIDE_STR_APD_LEN; 
     
    if(block->buflen < buflen ){ 
     
        buf = ExAllocatePool(NonPagedPool, buflen * sizeof(WCHAR) ); 
         
        if( NULL == buf) 
        {             
            return FALSE; 
        } 
         
        if(block->buf) 
        {         
            ExFreePool(block->buf); 
            block->buf = NULL; 
        } 
         
        block->buf = buf; 
        block->buflen = buflen ; 
    } 
     
    RtlZeroMemory(&block->ustr, sizeof(block->ustr) ); 
    RtlInitEmptyUnicodeString(&block->ustr, block->buf, buflen * sizeof(WCHAR)); 
     
    RtlCopyUnicodeString(&block->ustr, content); 
     
    return TRUE; 
} 
 
 
 
 
VOID 
CopyStr( 
  PVOID dst, 
  const PVOID src   
  ) 
//============================== 
// Copy A String To Dst. String  
// USTR_BLOCK TYPE 
//==============================     
{ 
    USTR_BLOCK *block_dst = (USTR_BLOCK*)dst; 
    USTR_BLOCK *block_src = (USTR_BLOCK*)src; 
     
    SetStrWithUniStr(block_dst, &block_src->ustr); 
} 
 
 
 
VOID 
AppendStrWithInt( 
  int num 
  ) 
//============================== 
// Append Int-Type  to String  
// USTR_BLOCK TYPE 
//==============================     
{ 
    assert(0); 
    //implement later 
} 
 
 
 
BOOLEAN 
AppendStrWithWideStr( 
  PVOID dst, 
  const WCHAR* str 
  ) 
//============================== 
// Append WideBytes String to String  
// USTR_BLOCK TYPE 
//==============================     
{ 
    USTR_BLOCK *block_dst = (USTR_BLOCK*)dst; 
    WCHAR *buf = NULL; 
    ULONG buflen = wcslen(str) + block_dst->ustr.Length + WIDE_STR_APD_LEN; 
     
    if(block_dst->buflen < buflen) 
    {     
        buf = ExAllocatePool(NonPagedPool, buflen * sizeof(WCHAR) ); 
         
        if( NULL == buf ) 
        {             
            return FALSE; 
        } 
         
        RtlZeroMemory(buf, buflen * sizeof(WCHAR) ); 
         
        if(block_dst->buf) 
        {             
            wcscpy(buf, block_dst->buf); 
            ExFreePool(block_dst->buf); 
             
            block_dst->buf = buf; 
            block_dst->buflen = buflen; 
        }         
    } 
     
    wcscat( block_dst->buf, str); 
     
    RtlZeroMemory(&block_dst->ustr, sizeof(block_dst->ustr) ); 
    RtlInitUnicodeString(&block_dst->ustr, block_dst->buf); 
     
    return TRUE; 
} 
 
 
 
 
BOOLEAN 
AppendStrWithUniStr( 
  PVOID dst, 
  PUNICODE_STRING str 
  ) 
//============================== 
// Append Uniocde String to String  
// USTR_BLOCK TYPE 
//==============================   
{ 
    USTR_BLOCK * block_dst = (USTR_BLOCK*)dst; 
    WCHAR *buf = NULL; 
    ULONG buflen = wcslen(block_dst->buf) + str->Length + WIDE_STR_APD_LEN; 
    ULONG oldstrlen = wcslen(block_dst->buf); 
     
    if(str->Length == 0) 
    {         
        return FALSE; 
    } 
     
    if(block_dst->buflen < buflen) 
    {     
        buf = ExAllocatePool(NonPagedPool, buflen * sizeof(WCHAR) ); 
        
        if(NULL == buf) 
        {         
            return FALSE; 
        } 
         
        RtlZeroMemory(buf, buflen * sizeof(WCHAR) ); 
         
        if(block_dst->buf) 
        {             
            wcscpy(buf, block_dst->buf); 
            ExFreePool(block_dst->buf); 
             
            block_dst->buf = buf; 
            block_dst->buflen = buflen; 
        }         
    }  
     
    wcscat(block_dst->buf, str->Buffer); 
     
    RtlZeroMemory( &block_dst->ustr, sizeof(block_dst->ustr) ); 
    RtlInitUnicodeString(&block_dst->ustr, block_dst->buf); 
     
    return TRUE; 
} 
 
 
 
 
BOOLEAN 
AppendStrWithStr( 
  PVOID dst, 
  PVOID str 
  ) 
//============================== 
// Append A String to String  
// USTR_BLOCK TYPE 
//==============================     
{ 
    USTR_BLOCK *block_str = (USTR_BLOCK*)str; 
    return AppendStrWithUniStr(dst, &block_str->ustr); 
} 
 
 
 
 
WCHAR* 
GetStrBuf( 
  PVOID str 
  ) 
//============================== 
// Get a String's buffer  
// USTR_BLOCK TYPE 
//==============================   
{ 
    USTR_BLOCK* block = (USTR_BLOCK*)str; 
    return block->buf; 
} 
 
 
 
 
PUNICODE_STRING 
GetStrUniStr( 
  PVOID str 
  ) 
//============================== 
// Get a String's Unicode string 
// USTR_BLOCK TYPE 
//==============================   
{ 
    USTR_BLOCK* block = (USTR_BLOCK*)str; 
    return &block->ustr; 
} 
 
 
 
 
ULONG 
GetStrBufLen( 
  PVOID str 
  ) 
//============================== 
// Get a String's buffer length 
// USTR_BLOCK TYPE 
//==============================     
{ 
    USTR_BLOCK* block = (USTR_BLOCK*)str; 
    return block->ustr.Length;     
}