static void demo_C_Unicode_strings() {
printf("\n* demo_C_Unicode_strings() --------- ***\n\n");
static const UChar text[]={ 0x41, 0x42, 0x43, 0 }; /* "ABC" */
static const UChar appendText[]={ 0x61, 0x62, 0x63, 0 }; /* "abc" */
static const UChar cmpText[]={ 0x61, 0x53, 0x73, 0x43, 0 }; /* "aSsC" */
UChar buffer[32];
int32_t compare;
int32_t length=u_strlen(text); /* length=3 */
/* simple ANSI C-style functions */
buffer[0]=0; /* empty, NUL-terminated string */
u_strncat(buffer, text, 1); /* append just n=1 character ('A') */
u_strcat(buffer, appendText); /* buffer=="Aabc" */
length=u_strlen(buffer); /* length=4 */
printUString("should be \"Aabc\": ", buffer, -1);
/* bitwise comparing buffer with text */
compare=u_strcmp(buffer, text);
if(compare<=0) {
printf("String comparison error, expected \"Aabc\" > \"ABC\"\n");
}
/* Build "A<sharp s>C" in the buffer... */
u_strcpy(buffer, text);
buffer[1]=0xdf; /* sharp s, case-compares equal to "ss" */
printUString("should be \"A<sharp s>C\": ", buffer, -1);
/* Compare two strings case-insensitively using full case folding */
compare=u_strcasecmp(buffer, cmpText, U_FOLD_CASE_DEFAULT);
if(compare!=0) {
printf("String case insensitive comparison error, expected \"AbC\" to be equal to \"ABC\"\n");
}
}
// Use hexnag macro. Similar to nag(), but preceed output with len bytes in hex from buffer.
void hexnag_internal(const char *funcname, const void *buffer, size_t len, const char *fmt, ...) {
va_list ap;
ustring us = USTRING_INITIALIZER;
size_t i;
for(i = 0; i < len; ++i) {
unsigned char c = ((const unsigned char*)buffer)[i];
if(printUString(&us, "%02x ", c) < 0) {
nag("Error while printing to ustring\n");
goto cleanup;
}
}
if(printUString(&us, "\t") < 0) {
nag("Error while printing to ustring\n");
goto cleanup;
}
va_start(ap, fmt);
if(vprintUString(&us, fmt, ap) < 0) {
nag("Error while printing to ustring\n");
goto cleanup;
}
va_end(ap);
flog("%s] %s\n", funcname, us.string);
cleanup:
reset_ustring(&us);
}
static int
stringize_icap_state_wrapper(ustring *u,const pollfd_state *pfd){
if(printUString(u,"<icap>") < 0){
return -1;
}
if(stringize_sdbuf_sizes(u,pfd->pfd.fd)){
return -1;
}
if(stringize_icap_state(u,get_const_pfd_icap(pfd))){
return -1;
}
if(printUString(u,"</icap>") < 0){
return -1;
}
return 0;
}
int stringize_icap_state(ustring *u,const icap_state *is){
if(is->urimethod){
if(printUString(u,"<%s/>",is->urimethod) < 0){
return -1;
}
}
if(is->encaps.hdrs){
if(stringize_oqueue_key(u,"hdrs",is->encaps.hdrs) < 0){
return -1;
}
}
if(is->encaps.body){
if(stringize_oqueue_key(u,"body",is->encaps.body) < 0){
return -1;
}
}
if(is->encaps.drainbody){
if(stringize_oqueue_key(u,"drain",is->encaps.drainbody) < 0){
return -1;
}
}
if(is->encaps.transbody){
if(stringize_oqueue_key(u,"trans",is->encaps.transbody) < 0){
return -1;
}
}
return 0;
}
int rebuild_params(ParamNodeType *param_list, ustring *u, const char *sep) {
while(param_list) {
if(param_list->param_value.value) {
if(printUString(u, "%s=%s", param_list->param_value.name, param_list->param_value.value) < 0) {
return 1;
}
} else {
if(printUString(u, "%s", param_list->param_value.name) < 0) {
return 1;
}
}
param_list = param_list->next;
if(param_list) {
if(printUString(u, "%s", sep) < 0) {
return 1;
}
}
}
return 0;
}
static void
demo_utf_h_macros() {
static UChar input[]={ 0x0061, 0xd800, 0xdc00, 0xdbff, 0xdfff, 0x0062 };
UChar32 c;
int32_t i;
UBool isError;
printf("\n* demo_utf_h_macros() -------------- ***\n\n");
printUString("iterate forward through: ", input, UPRV_LENGTHOF(input));
for(i=0; i<UPRV_LENGTHOF(input); /* U16_NEXT post-increments */) {
/* Iterating forwards
Codepoint at offset 0: U+0061
Codepoint at offset 1: U+10000
Codepoint at offset 3: U+10ffff
Codepoint at offset 5: U+0062
*/
printf("Codepoint at offset %d: U+", i);
U16_NEXT(input, i, UPRV_LENGTHOF(input), c);
printf("%04x\n", c);
}
puts("");
isError=FALSE;
i=1; /* write position, gets post-incremented so needs to be in an l-value */
U16_APPEND(input, i, UPRV_LENGTHOF(input), 0x0062, isError);
printUString("iterate backward through: ", input, UPRV_LENGTHOF(input));
for(i=UPRV_LENGTHOF(input); i>0; /* U16_PREV pre-decrements */) {
U16_PREV(input, 0, i, c);
/* Iterating backwards
Codepoint at offset 5: U+0062
Codepoint at offset 3: U+10ffff
Codepoint at offset 2: U+dc00 -- unpaired surrogate because lead surr. overwritten
Codepoint at offset 1: U+0062 -- by this BMP code point
Codepoint at offset 0: U+0061
*/
printf("Codepoint at offset %d: U+%04x\n", i, c);
}
}
int stringize_ipset(ustring *u,const ipset *is){
unsigned z;
if(printUString(u,"%c",'[') < 0){
return -1;
}
for(z = 0 ; z < is->rangecount ; ++z){
iprange *cur = &is->ranges[z];
if(z && printUString(u,",") < 0){
return -1;
}
if(stringize_iprange(u,cur)){
return -1;
}
}
if(printUString(u,"%c",']') < 0){
return -1;
}
return 0;
}
static int
stringize_iprange(ustring *u,const iprange *ir){
char buf[INET_ADDRSTRLEN];
uint32_t tmp;
tmp = htonl(ir->lower);
if(inet_ntop(AF_INET,&tmp,buf,INET_ADDRSTRLEN) == NULL){
return -1;
}
if(printUString(u,"%s",buf) < 0){
return -1;
}
if(ir->upper != ir->lower){
tmp = htonl(ir->upper);
if(inet_ntop(AF_INET,&tmp,buf,INET_ADDRSTRLEN) == NULL){
return -1;
}
if(printUString(u,"-%s",buf) < 0){
return -1;
}
}
return 0;
}
static int
repopulate_predicate(struct Predicate *p, struct icap_state *is, SiteInfoType *si, unsigned int uid,
ustring *xattr) {
ssize_t i;
pred_set_rep(p, si->rep);
if(printUString(xattr, "; rep: %d", si->rep) < 0) {
return -1;
}
if(printUString(xattr, "; cat:") < 0) {
return -1;
}
for(i = 0; i < si->num_cats; ++i) {
if(printUString(xattr, " %u", si->cat_array[i]) < 0) {
return -1;
}
pred_add_cat(p, si->cat_array[i]);
}
pred_set_uid(p, uid);
pred_set_respmod_flag(p); // Indicate that we're in RESPMOD now -- all rules can be evaluated
pred_set_hdrs(p, is); // Copy header fields from icap_state into header map
return 0;
}
int stringize_memory_usage(ustring *u){
uintmax_t reqd,fail;
intmax_t used;
pthread_mutex_lock(&memlock);
used = allocs_used;
reqd = allocs_reqd;
fail = allocs_fail;
pthread_mutex_unlock(&memlock);
if(printUString(u,"<memstats><limit>%ju</limit>"
"<usedtotal>%ju</usedtotal>"
"<req>%ju</req>"
"<failedreq>%ju</failedreq>"
"<outstanding>%jd</outstanding>"
"</memstats>"
,memory_usage_limit,mem_used(),
reqd,fail,used) < 0){
return -1;
}
return 0;
}
// Helper function to convert a password into a password hash.
unsigned char *gen_pw_hash(const char *username, const char *password) {
ustring us = USTRING_INITIALIZER;
unsigned char *result = NULL;
const char *pa_salt = "<P$db=\\!Y&!oop@LFZ{x(#Tn!309oukRn<9'6oK\\[Sqc:&R5-u]P'T_\"r>R7OzD_r>R7OzD";
if(printUString(&us, "%s%s%s", pa_salt, username, password) < 0) {
nag("Concatenation of input data failed\n");
goto cleanup;
}
result = Malloc("pw_hash", SHA_DIGEST_LENGTH);
if(!result) {
nag("No memory for pw_hash\n");
goto cleanup;
}
SHA1((const unsigned char *)us.string, us.current, result);
cleanup:
reset_ustring(&us);
return result;
}
static void demoCaseMapInC() {
/*
* input=
* "aB<capital sigma>"
* "iI<small dotless i><capital dotted I> "
* "<sharp s> <small lig. ffi>"
* "<small final sigma><small sigma><capital sigma>"
*/
static const UChar input[]={
0x61, 0x42, 0x3a3,
0x69, 0x49, 0x131, 0x130, 0x20,
0xdf, 0x20, 0xfb03,
0x3c2, 0x3c3, 0x3a3, 0
};
UChar buffer[32];
UErrorCode errorCode;
UChar32 c;
int32_t i, j, length;
UBool isError;
printf("\n* demoCaseMapInC() ----------------- ***\n\n");
/*
* First, use simple case mapping functions which provide
* 1:1 code point mappings without context/locale ID.
*
* Note that some mappings will not be "right" because some "real"
* case mappings require context, depend on the locale ID,
* and/or result in a change in the number of code points.
*/
printUString("input string: ", input, -1);
/* uppercase */
isError=FALSE;
for(i=j=0; j<UPRV_LENGTHOF(buffer) && !isError; /* U16_NEXT post-increments */) {
U16_NEXT(input, i, INT32_MAX, c); /* without length because NUL-terminated */
if(c==0) {
break; /* stop at terminating NUL, no need to terminate buffer */
}
c=u_toupper(c);
U16_APPEND(buffer, j, UPRV_LENGTHOF(buffer), c, isError);
}
printUString("simple-uppercased: ", buffer, j);
/* lowercase */
isError=FALSE;
for(i=j=0; j<UPRV_LENGTHOF(buffer) && !isError; /* U16_NEXT post-increments */) {
U16_NEXT(input, i, INT32_MAX, c); /* without length because NUL-terminated */
if(c==0) {
break; /* stop at terminating NUL, no need to terminate buffer */
}
c=u_tolower(c);
U16_APPEND(buffer, j, UPRV_LENGTHOF(buffer), c, isError);
}
printUString("simple-lowercased: ", buffer, j);
/* titlecase */
isError=FALSE;
for(i=j=0; j<UPRV_LENGTHOF(buffer) && !isError; /* U16_NEXT post-increments */) {
U16_NEXT(input, i, INT32_MAX, c); /* without length because NUL-terminated */
if(c==0) {
break; /* stop at terminating NUL, no need to terminate buffer */
}
c=u_totitle(c);
U16_APPEND(buffer, j, UPRV_LENGTHOF(buffer), c, isError);
}
printUString("simple-titlecased: ", buffer, j);
/* case-fold/default */
isError=FALSE;
for(i=j=0; j<UPRV_LENGTHOF(buffer) && !isError; /* U16_NEXT post-increments */) {
U16_NEXT(input, i, INT32_MAX, c); /* without length because NUL-terminated */
if(c==0) {
break; /* stop at terminating NUL, no need to terminate buffer */
}
c=u_foldCase(c, U_FOLD_CASE_DEFAULT);
U16_APPEND(buffer, j, UPRV_LENGTHOF(buffer), c, isError);
}
printUString("simple-case-folded/default: ", buffer, j);
/* case-fold/Turkic */
isError=FALSE;
for(i=j=0; j<UPRV_LENGTHOF(buffer) && !isError; /* U16_NEXT post-increments */) {
U16_NEXT(input, i, INT32_MAX, c); /* without length because NUL-terminated */
if(c==0) {
break; /* stop at terminating NUL, no need to terminate buffer */
}
c=u_foldCase(c, U_FOLD_CASE_EXCLUDE_SPECIAL_I);
U16_APPEND(buffer, j, UPRV_LENGTHOF(buffer), c, isError);
}
printUString("simple-case-folded/Turkic: ", buffer, j);
/*
* Second, use full case mapping functions which provide
* 1:n code point mappings (n can be 0!) and are sensitive to context and locale ID.
*
* Note that lower/upper/titlecasing take a locale ID while case-folding
* has bit flag options instead, by design of the Unicode SpecialCasing.txt UCD file.
*
* Also, string titlecasing requires a BreakIterator to find starts of words.
* The sample code here passes in a NULL pointer; u_strToTitle() will open and close a default
* titlecasing BreakIterator automatically.
* For production code where many strings are titlecased it would be more efficient
* to open a BreakIterator externally and pass it in.
*/
printUString("\ninput string: ", input, -1);
/* lowercase/English */
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, UPRV_LENGTHOF(buffer), input, -1, "en", &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-lowercased/en: ", buffer, length);
} else {
printf("error in u_strToLower(en)=%ld error=%s\n", length, u_errorName(errorCode));
}
/* lowercase/Turkish */
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, UPRV_LENGTHOF(buffer), input, -1, "tr", &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-lowercased/tr: ", buffer, length);
} else {
printf("error in u_strToLower(tr)=%ld error=%s\n", length, u_errorName(errorCode));
}
/* uppercase/English */
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer), input, -1, "en", &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-uppercased/en: ", buffer, length);
} else {
printf("error in u_strToUpper(en)=%ld error=%s\n", length, u_errorName(errorCode));
}
/* uppercase/Turkish */
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer), input, -1, "tr", &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-uppercased/tr: ", buffer, length);
} else {
printf("error in u_strToUpper(tr)=%ld error=%s\n", length, u_errorName(errorCode));
}
/* titlecase/English */
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer), input, -1, NULL, "en", &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-titlecased/en: ", buffer, length);
} else {
printf("error in u_strToTitle(en)=%ld error=%s\n", length, u_errorName(errorCode));
}
/* titlecase/Turkish */
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer), input, -1, NULL, "tr", &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-titlecased/tr: ", buffer, length);
} else {
printf("error in u_strToTitle(tr)=%ld error=%s\n", length, u_errorName(errorCode));
}
/* case-fold/default */
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer), input, -1, U_FOLD_CASE_DEFAULT, &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-case-folded/default: ", buffer, length);
} else {
printf("error in u_strFoldCase(default)=%ld error=%s\n", length, u_errorName(errorCode));
}
/* case-fold/Turkic */
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer), input, -1, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &errorCode);
if(U_SUCCESS(errorCode)) {
printUString("full-case-folded/Turkic: ", buffer, length);
} else {
printf("error in u_strFoldCase(Turkic)=%ld error=%s\n", length, u_errorName(errorCode));
}
}
