From mboxrd@z Thu Jan 1 00:00:00 1970 From: Markus Mayer Subject: [PATCH v3 1/7] lib: string: add functions to case-convert strings Date: Fri, 8 Jul 2016 15:43:08 -0700 Message-ID: <1468017794-4818-2-git-send-email-mmayer@broadcom.com> References: <1468017794-4818-1-git-send-email-mmayer@broadcom.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1468017794-4818-1-git-send-email-mmayer-dY08KVG/lbpWk0Htik3J/w@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: nouveau-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Nouveau" To: Andrew Morton , Al Viro , Rasmus Villemoes , Chris Metcalf , Kees Cook Cc: devel-gWbeCf7V1WCQmaza687I9mD2FQJk+8+b@public.gmane.org, linux-scsi-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-pm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, speakup-UPO/6gOIxNZglr+F8WMZYdi2O/JbrIOy@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-acpi-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, target-devel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org List-Id: linux-scsi@vger.kernel.org QWRkIGEgY29sbGVjdGlvbiBvZiBnZW5lcmljIGZ1bmN0aW9ucyB0byBjb252ZXJ0IHN0cmluZ3Mg dG8gbG93ZXJjYXNlCm9yIHVwcGVyY2FzZS4KCkNoYW5naW5nIHRoZSBjYXNlIG9mIGEgc3RyaW5n ICh3aXRoIG9yIHdpdGhvdXQgY29weWluZyBpdCBmaXJzdCkgc2VlbXMKdG8gYmUgYSByZWN1cnJp bmcgcmVxdWlyZW1lbnQgaW4gdGhlIGtlcm5lbCB0aGF0IGlzIGN1cnJlbnRseSBiZWluZwpzb2x2 ZWQgYnkgc2V2ZXJhbCBkdXBsaWNhdGVkIGltcGxlbWVudGF0aW9ucyBkb2luZyB0aGUgc2FtZSB0 aGluZy4gVGhpcwpjaGFuZ2UgYWltcyBhdCByZWR1Y2luZyB0aGlzIGNvZGUgZHVwbGljYXRpb24u CgpUaGUgbmV3IGZ1bmN0aW9ucyBhcmUKICAgIHZvaWQgc3RybGNweXRvdXBwZXIoY2hhciAqZHN0 LCBjb25zdCBjaGFyICpzcmMsIHNpemVfdCBsZW4pOwogICAgdm9pZCBzdHJsY3B5dG9sb3dlcihj aGFyICpkc3QsIGNvbnN0IGNoYXIgKnNyYywgc2l6ZV90IGxlbik7CiAgICB2b2lkIHN0cmNweXRv dXBwZXIoY2hhciAqZHN0LCBjb25zdCBjaGFyICpzcmMpOwogICAgdm9pZCBzdHJjcHl0b2xvd2Vy KGNoYXIgKmRzdCwgY29uc3QgY2hhciAqc3JjKTsKICAgIHZvaWQgc3RydG91cHBlcihjaGFyICpz KTsKICAgIHZvaWQgc3RydG9sb3dlcihjaGFyICpzKTsKClRoZSAic3RyW2xdY3B5dG8qIiB2ZXJz aW9ucyBvZiB0aGUgZnVuY3Rpb24gdGFrZSBhIGRlc3RpbmF0aW9uIHN0cmluZwphbmQgYSBzb3Vy Y2Ugc3RyaW5nIGFzIGFyZ3VtZW50cy4gVGhlICJzdHJsY3B5dG8qIiB2ZXJzaW9ucyBhZGRpdGlv bmFsbHkKdGFrZSBhIGxlbmd0aCBhcmd1bWVudCBsaWtlIHN0cmxjcHkoKSBpdHNlbGYuIExhc3Rs eSwgdGhlIHN0cnRvKgpmdW5jdGlvbnMgdGFrZSBhIHNpbmdsZSBzdHJpbmcgYXJndW1lbnQgYW5k IG1vZGlmeSB0aGUgcGFzc2VkLWluIHN0cmluZy4KCkxpa2Ugc3RybGNweSgpLCBhbmQgdW5saWtl IHN0cm5jcHkoKSwgdGhlIGZ1bmN0aW9ucyBndWFyYW50ZWUgTlVMTAp0ZXJtaW5hdGlvbiBvZiB0 aGUgZGVzdGluYXRpb24gc3RyaW5nLgoKU2lnbmVkLW9mZi1ieTogTWFya3VzIE1heWVyIDxtbWF5 ZXJAYnJvYWRjb20uY29tPgotLS0KIGluY2x1ZGUvbGludXgvc3RyaW5nLmggfCA0MCArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBsaWIvc3RyaW5nLmMgICAgICAgICAg IHwgMzggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDIgZmlsZXMgY2hh bmdlZCwgNzggaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3RyaW5n LmggYi9pbmNsdWRlL2xpbnV4L3N0cmluZy5oCmluZGV4IDI2YjZmNmEuLjM2YzlkMTQgMTAwNjQ0 Ci0tLSBhL2luY2x1ZGUvbGludXgvc3RyaW5nLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdHJpbmcu aApAQCAtMTE2LDYgKzExNiw4IEBAIGV4dGVybiB2b2lkICogbWVtY2hyKGNvbnN0IHZvaWQgKixp bnQsX19rZXJuZWxfc2l6ZV90KTsKICNlbmRpZgogdm9pZCAqbWVtY2hyX2ludihjb25zdCB2b2lk ICpzLCBpbnQgYywgc2l6ZV90IG4pOwogY2hhciAqc3RycmVwbGFjZShjaGFyICpzLCBjaGFyIG9s ZCwgY2hhciBuZXcpOworZXh0ZXJuIHZvaWQgc3RybGNweXRvdXBwZXIoY2hhciAqZHN0LCBjb25z dCBjaGFyICpzcmMsIHNpemVfdCBsZW4pOworZXh0ZXJuIHZvaWQgc3RybGNweXRvbG93ZXIoY2hh ciAqZHN0LCBjb25zdCBjaGFyICpzcmMsIHNpemVfdCBsZW4pOwogCiBleHRlcm4gdm9pZCBrZnJl ZV9jb25zdChjb25zdCB2b2lkICp4KTsKIApAQCAtMTY5LDQgKzE3MSw0MiBAQCBzdGF0aWMgaW5s aW5lIGNvbnN0IGNoYXIgKmtiYXNlbmFtZShjb25zdCBjaGFyICpwYXRoKQogCXJldHVybiB0YWls ID8gdGFpbCArIDEgOiBwYXRoOwogfQogCisvKioKKyAqIHN0cmNweXRvdXBwZXIgLSBDb3B5IHN0 cmluZyBhbmQgY29udmVydCB0byB1cHBlcmNhc2UuCisgKiBAZHN0OiBUaGUgYnVmZmVyIHRvIHN0 b3JlIHRoZSByZXN1bHQuCisgKiBAc3JjOiBUaGUgc3RyaW5nIHRvIGNvbnZlcnQgdG8gdXBwZXJj YXNlLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQgc3RyY3B5dG91cHBlcihjaGFyICpkc3QsIGNv bnN0IGNoYXIgKnNyYykKK3sKKwlzdHJsY3B5dG91cHBlcihkc3QsIHNyYywgLTEpOworfQorCisv KioKKyAqIHN0cmNweXRvbG93ZXIgLSBDb3B5IHN0cmluZyBhbmQgY29udmVydCB0byBsb3dlcmNh c2UuCisgKiBAZHN0OiBUaGUgYnVmZmVyIHRvIHN0b3JlIHRoZSByZXN1bHQuCisgKiBAc3JjOiBU aGUgc3RyaW5nIHRvIGNvbnZlcnQgdG8gbG93ZXJjYXNlLgorICovCitzdGF0aWMgaW5saW5lIHZv aWQgc3RyY3B5dG9sb3dlcihjaGFyICpkc3QsIGNvbnN0IGNoYXIgKnNyYykKK3sKKwlzdHJsY3B5 dG9sb3dlcihkc3QsIHNyYywgLTEpOworfQorCisvKioKKyAqIHN0cnRvdXBwZXIgLSBDb252ZXJ0 IHN0cmluZyB0byB1cHBlcmNhc2UuCisgKiBAczogVGhlIHN0cmluZyB0byBvcGVyYXRlIG9uLgor ICovCitzdGF0aWMgaW5saW5lIHZvaWQgc3RydG91cHBlcihjaGFyICpzKQoreworCXN0cmxjcHl0 b3VwcGVyKHMsIHMsIC0xKTsKK30KKworLyoqCisgKiBzdHJ0b2xvd2VyIC0gQ29udmVydCBzdHJp bmcgdG8gbG93ZXJjYXNlLgorICogQHM6IFRoZSBzdHJpbmcgdG8gb3BlcmF0ZSBvbi4KKyAqLwor c3RhdGljIGlubGluZSB2b2lkIHN0cnRvbG93ZXIoY2hhciAqcykKK3sKKwlzdHJsY3B5dG9sb3dl cihzLCBzLCAtMSk7Cit9CisKICNlbmRpZiAvKiBfTElOVVhfU1RSSU5HX0hfICovCmRpZmYgLS1n aXQgYS9saWIvc3RyaW5nLmMgYi9saWIvc3RyaW5nLmMKaW5kZXggZWQ4MzU2Mi4uZmQ4YzQyNyAx MDA2NDQKLS0tIGEvbGliL3N0cmluZy5jCisrKyBiL2xpYi9zdHJpbmcuYwpAQCAtOTUyLDMgKzk1 Miw0MSBAQCBjaGFyICpzdHJyZXBsYWNlKGNoYXIgKnMsIGNoYXIgb2xkLCBjaGFyIG5ldykKIAly ZXR1cm4gczsKIH0KIEVYUE9SVF9TWU1CT0woc3RycmVwbGFjZSk7CisKKy8qKgorICogc3RybGNw eXRvdXBwZXIgLSBDb3B5IGEgbGVuZ3RoLWxpbWl0ZWQgc3RyaW5nIGFuZCBjb252ZXJ0IHRvIHVw cGVyY2FzZS4KKyAqIEBkc3Q6IFRoZSBidWZmZXIgdG8gc3RvcmUgdGhlIHJlc3VsdC4KKyAqIEBz cmM6IFRoZSBzdHJpbmcgdG8gY29udmVydCB0byB1cHBlcmNhc2UuCisgKiBAbGVuOiBNYXhpbXVt IHN0cmluZyBsZW5ndGguIE1heSBiZSBTSVpFX01BWCAoLTEpIHRvIHNldCBubyBsaW1pdC4KKyAq Lwordm9pZCBzdHJsY3B5dG91cHBlcihjaGFyICpkc3QsIGNvbnN0IGNoYXIgKnNyYywgc2l6ZV90 IGxlbikKK3sKKwlzaXplX3QgaTsKKworCWlmICghbGVuKQorCQlyZXR1cm47CisKKwlmb3IgKGkg PSAwOyBpIDwgbGVuICYmIHNyY1tpXTsgKytpKQorCQlkc3RbaV0gPSB0b3VwcGVyKHNyY1tpXSk7 CisJZHN0W2kgPCBsZW4gPyBpIDogaSAtIDFdID0gJ1wwJzsKK30KK0VYUE9SVF9TWU1CT0woc3Ry bGNweXRvdXBwZXIpOworCisvKioKKyAqIHN0cmxjcHl0b2xvd2VyIC0gQ29weSBhIGxlbmd0aC1s aW1pdGVkIHN0cmluZyBhbmQgY29udmVydCB0byBsb3dlcmNhc2UuCisgKiBAZHN0OiBUaGUgYnVm ZmVyIHRvIHN0b3JlIHRoZSByZXN1bHQuCisgKiBAc3JjOiBUaGUgc3RyaW5nIHRvIGNvbnZlcnQg dG8gbG93ZXJjYXNlLgorICogQGxlbjogTWF4aW11bSBzdHJpbmcgbGVuZ3RoLiBNYXkgYmUgU0la RV9NQVggKC0xKSB0byBzZXQgbm8gbGltaXQuCisgKi8KK3ZvaWQgc3RybGNweXRvbG93ZXIoY2hh ciAqZHN0LCBjb25zdCBjaGFyICpzcmMsIHNpemVfdCBsZW4pCit7CisJc2l6ZV90IGk7CisKKwlp ZiAoIWxlbikKKwkJcmV0dXJuOworCisJZm9yIChpID0gMDsgaSA8IGxlbiAmJiBzcmNbaV07ICsr aSkKKwkJZHN0W2ldID0gdG9sb3dlcihzcmNbaV0pOworCWRzdFtpIDwgbGVuID8gaSA6IGkgLSAx XSA9ICdcMCc7Cit9CitFWFBPUlRfU1lNQk9MKHN0cmxjcHl0b2xvd2VyKTsKLS0gCjIuNy40Cgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpOb3V2ZWF1IG1h aWxpbmcgbGlzdApOb3V2ZWF1QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL25vdXZlYXUK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932889AbcGHWoX (ORCPT ); Fri, 8 Jul 2016 18:44:23 -0400 Received: from mail-pa0-f54.google.com ([209.85.220.54]:35966 "EHLO mail-pa0-f54.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932568AbcGHWoG (ORCPT ); Fri, 8 Jul 2016 18:44:06 -0400 From: Markus Mayer To: Andrew Morton , Al Viro , Rasmus Villemoes , Chris Metcalf , Kees Cook Cc: Markus Mayer , dri-devel@lists.freedesktop.org, nouveau@lists.freedesktop.org, linux-acpi@vger.kernel.org, speakup@linux-speakup.org, devel@driverdev.osuosl.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 1/7] lib: string: add functions to case-convert strings Date: Fri, 8 Jul 2016 15:43:08 -0700 Message-Id: <1468017794-4818-2-git-send-email-mmayer@broadcom.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1468017794-4818-1-git-send-email-mmayer@broadcom.com> References: <1468017794-4818-1-git-send-email-mmayer@broadcom.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add a collection of generic functions to convert strings to lowercase or uppercase. Changing the case of a string (with or without copying it first) seems to be a recurring requirement in the kernel that is currently being solved by several duplicated implementations doing the same thing. This change aims at reducing this code duplication. The new functions are void strlcpytoupper(char *dst, const char *src, size_t len); void strlcpytolower(char *dst, const char *src, size_t len); void strcpytoupper(char *dst, const char *src); void strcpytolower(char *dst, const char *src); void strtoupper(char *s); void strtolower(char *s); The "str[l]cpyto*" versions of the function take a destination string and a source string as arguments. The "strlcpyto*" versions additionally take a length argument like strlcpy() itself. Lastly, the strto* functions take a single string argument and modify the passed-in string. Like strlcpy(), and unlike strncpy(), the functions guarantee NULL termination of the destination string. Signed-off-by: Markus Mayer --- include/linux/string.h | 40 ++++++++++++++++++++++++++++++++++++++++ lib/string.c | 38 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/include/linux/string.h b/include/linux/string.h index 26b6f6a..36c9d14 100644 --- a/include/linux/string.h +++ b/include/linux/string.h @@ -116,6 +116,8 @@ extern void * memchr(const void *,int,__kernel_size_t); #endif void *memchr_inv(const void *s, int c, size_t n); char *strreplace(char *s, char old, char new); +extern void strlcpytoupper(char *dst, const char *src, size_t len); +extern void strlcpytolower(char *dst, const char *src, size_t len); extern void kfree_const(const void *x); @@ -169,4 +171,42 @@ static inline const char *kbasename(const char *path) return tail ? tail + 1 : path; } +/** + * strcpytoupper - Copy string and convert to uppercase. + * @dst: The buffer to store the result. + * @src: The string to convert to uppercase. + */ +static inline void strcpytoupper(char *dst, const char *src) +{ + strlcpytoupper(dst, src, -1); +} + +/** + * strcpytolower - Copy string and convert to lowercase. + * @dst: The buffer to store the result. + * @src: The string to convert to lowercase. + */ +static inline void strcpytolower(char *dst, const char *src) +{ + strlcpytolower(dst, src, -1); +} + +/** + * strtoupper - Convert string to uppercase. + * @s: The string to operate on. + */ +static inline void strtoupper(char *s) +{ + strlcpytoupper(s, s, -1); +} + +/** + * strtolower - Convert string to lowercase. + * @s: The string to operate on. + */ +static inline void strtolower(char *s) +{ + strlcpytolower(s, s, -1); +} + #endif /* _LINUX_STRING_H_ */ diff --git a/lib/string.c b/lib/string.c index ed83562..fd8c427 100644 --- a/lib/string.c +++ b/lib/string.c @@ -952,3 +952,41 @@ char *strreplace(char *s, char old, char new) return s; } EXPORT_SYMBOL(strreplace); + +/** + * strlcpytoupper - Copy a length-limited string and convert to uppercase. + * @dst: The buffer to store the result. + * @src: The string to convert to uppercase. + * @len: Maximum string length. May be SIZE_MAX (-1) to set no limit. + */ +void strlcpytoupper(char *dst, const char *src, size_t len) +{ + size_t i; + + if (!len) + return; + + for (i = 0; i < len && src[i]; ++i) + dst[i] = toupper(src[i]); + dst[i < len ? i : i - 1] = '\0'; +} +EXPORT_SYMBOL(strlcpytoupper); + +/** + * strlcpytolower - Copy a length-limited string and convert to lowercase. + * @dst: The buffer to store the result. + * @src: The string to convert to lowercase. + * @len: Maximum string length. May be SIZE_MAX (-1) to set no limit. + */ +void strlcpytolower(char *dst, const char *src, size_t len) +{ + size_t i; + + if (!len) + return; + + for (i = 0; i < len && src[i]; ++i) + dst[i] = tolower(src[i]); + dst[i < len ? i : i - 1] = '\0'; +} +EXPORT_SYMBOL(strlcpytolower); -- 2.7.4