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)); } }