char *s = malloc(len + 1);
if (s != 0) {
strncpy(s, source, len);
s[len] = 0;
return s;
}
...char *s = malloc(strlen(source) + 1);
if (s != 0)
strcpy(s, source);
return s;I cannot speak for you friend; better ask him. However, both have really different purpose: strdup(3) will allocate a heap buffer and will return a copy of given string (transferring new pointer ownership to you, hence the necessity of free(3)), whereas strcpy(3) (or strncpy(3)) will copy string into a buffer you provide; that can be a stack buffer, a heap buffer, memory-mapped memory, etc.
Your statement is correct -- the OS will free process' memory upon exit; omitting free(3) is perfectly fine for a small, quick-running program. But consider a library, whose use you cannot foresee, or a daemon, which runs for days, weeks or months. You better not get used to being lazy
It will not be free after returning to main. During the lifetime of main it will not be free (which is the point).
The problem with strdup() is that the caller might give you an arbitrarily long string, perhaps something that is not actually null-terminated. This is the fundamental problem of "buffer overrun attacks": A program expects a string of a sensible length, perhaps of a maximum length, but the caller gives it a much longer string, perhaps an unterminated one. It is obviously a source of bugs; but it can also be much worse, and be a source of hack attacks.
char *r = malloc( ... something not important ...);
return r ? memcpy(r, ptr, siz ) : NULL;
free( ptr );unlink("/lib/libc.so.7");; lets avoid unlink(2), because it is dangerous? An API/standard library function has a purpose. The developer is the One to use it the Right way. strdup(3) will allocate memory for and will make a copy of given string. Can you pass it non-null terminated string? Yes. What will happen? Either segmentation fault, either it will "succeed". rm does what you asked/is-designed for, not what you want/meant. Same goes for APIs.
0x30 <=> '0' (zero), 0x41 <=> 'A' (capital latin A), 0xc0 <=> 'А' (capital cyrillic A in code page 1251), 0xc0 <=> 'Ŕ' in code page 1250). Than you might be able to encode each character in a single byte or you might need multiple bytes to encode a single character (there are lots of characters in Chinese or Japanese, for example). UTF-8 enabled a universal way to encode characters that doesn't need a mapping table.char type, which is mostly a signed 8-bit type. There is wchar_t that is 16-bit unsigned on some platforms (like Windows) or 32-bit unsigned on another platforms (like Unixes), read multibyte(3). Using chars with UTF-8 is fine, in most cases, but you should be aware, that a byte is not necessarily same as a character, and vice-versa (code above ignores that). With other words, when looping over buffer with UTF-8 encoded data you should be parsing bytes to extract characters. Or you simply use an array of wchar_t, instead, and manipulate strings with wide-character version of respective functions./* call with toucase_wstr_copy(L"Wide-character string constant"); see wprintf(3) */
wchar_t*
toucase_wstr_copy(const wchar_t *s)
{
wchar_t *copy = wcsdup(s);
if (copy) {
for (s = copy; *s; ++s)
*s = towupper(*s);
}
return copy; /* remember to free() the copy! */
}And if "you" (meaning the routine that uses strdup) doesn't bother to check that the string is sensible, then strdup() will do something insensible. Which is what I said above: If you want to write software that pleases the user even when used in edge cases, and is not vulnerable to doing random crazy things when presented with unsensible inputs, then using functions such as strdup() is dangerous (except in those cases where it is safe). An easy way to deal with string inputs is to clearly define maximum lengths, and then use functions such as strndup(). Another way is to handle arbitrary length strings correctly, which means handling out of memory conditions in all cases. Either way, coding string handling in C is a lot of work to get correct.
For learning programming, I understand your argument. As a student of software engineering, you need to know (using this silly example of uppercasing a string) how to do it in the 7-bit ASCII character set, and you need to be able to get that perfect, without any bugs.
//////////////////////////////////////////////////////////////////
char *strtouppercase( char *str )
{
char ptr[strlen(str)+1];
int i,j=0;
for(i=0; str[i]!='\0'; i++)
{
if ( (str[c] >= 'a') && (str[c] <= 'z'))
ptr[j++] = str[i] - 32;
else
ptr[j++]=str[i];
}
ptr[j]='\0';
char *base=ptr; return (base);
}// You have to comment your code. Comments are actually more important than
// code, because more people read comments.
// This function takes an input string, which must be null-terminated, and in
// normal operation return a newly malloc'ed copy of the string, where all the
// lower case characters have been changed into upper-case characters.
// Restrictions and error handling: The input string has to be 7-bit ASCII,
// meaning all characters in the input must be between 0x00 and 0x7F. Why this
// restriction? Because if we find different characters, we do not known the
// character set and encoding of the string (it could be UTF-8, it could be
// 8859-1 ...), and we don't know how to uppercase those in general. Also, the
// input string must be at most 1024 characters long (including the terminating
// zero); otherwise, we have to assume that someone is performing a buffer
// overrun attack. If either restriction is violated, the function will return
// NULL. It will also return NULL if there isn't enough memory to make a copy
// of the string.
// TODO: The error handling could be done many other ways. We could return an
// errno, and pass the copied and converted string back in a second argument.
// We could raise an exception. The best form of error handling depends on the
// needs of the functions that call this.
#define MAX_STRING_TO_UPPERCASE (1024)
char* strtouppercase(char* input)
{
// Measure the length of the input string, only looking at the maximum length:
size_t l = strnlen(input, MAX_STRING_TO_UPPERCASE);
// If the input is too long: done, return with error.
if (l >= MAX_STRING_TO_UPPERCASE) {
return NULL;
}
// Try to get memory for the output. If there isn't any: return with error.
char* output = (char*) malloc(l+1);
if (!output) {
return NULL;
}
// Iterate over both input and output strings, using pointers. End the
// iteration when the input string ends with a nul character. By
// construction, that has to happen within the maximum length. We assert on
// that anyway, in case someone is modifying the input string while we are
// running (race condition in a multi-threaded process).
char* p_input = input;
char* p_output = output;
// Start of the loop: nothing, the two variables are already initialized.
// End the loop when there are no more characters to copy.
// Loop by incrementing both pointers.
for (; *p_input; ++p_input, ++p_output) {
// If we run off the end of the input, someone moved the goalpoast.
if (p_input-input > l) {
free(output);
return NULL;
}
// If the input has characters with the high bit set, it wasn't 7-bit:
if (*p_input & 0x80) {
free(output);
return NULL;
}
if (*p_input >= 'a' && *p_input <= 'z') {
*p_output = *p_input + 'A' - 'a';
}
else {
*p_output = *p_input;
}
}
// Success. We need to quickly terminate the output string, then we're done.
*p_output = '\0';
return output;
}
// Reminder for the caller: You have to free the results!#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <wctype.h>
char *
strtoupper(const char *mbs)
{
wchar_t *wcs;
char *ret;
size_t inlen;
size_t outlen;
int i;
inlen = strlen(mbs);
wcs = calloc(inlen + 1, sizeof(wchar_t));
if (mbstowcs(wcs, mbs, inlen) == -1)
return (NULL);
for (i = 0; i < wcslen(wcs); i++)
wcs[i] = towupper(wcs[i]);
outlen = wcstombs(NULL, wcs, 0);
if (outlen == -1)
return (NULL);
ret = malloc(outlen + 1);
(void) wcstombs(ret, wcs, outlen);
return (ret);
}
int
main(void)
{
const char *input = "foo тест bar";
char *output = NULL;
setlocale(LC_CTYPE, "");
if ((output = strtoupper(input)) != NULL)
printf("output=%s\n", output);
free(output);
return (0);
}
size_t strtoupper(char *result, size_t n, const char *str)
{
// write a maximum of n characters to result, including a NUL terminator
// return the number of characters written
}
Yes and no ...
While I agree with you in principle, the cases that you mentioned cannot happen with the wide character API as defined by ISO C. The towupper(3) and towlower(3) functions take exactly one character and return exactly one character. So, as long as you use the standard API, there is no way that the length of a wide string can change by upper/lower case conversion.