r25027: Fix more warnings.
[jelmer/samba4-debian.git] / source / lib / charset / charcnv.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Character set conversion Extensions
4    Copyright (C) Igor Vergeichik <iverg@mail.ru> 2001
5    Copyright (C) Andrew Tridgell 2001
6    Copyright (C) Simo Sorce 2001
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
21 */
22 #include "includes.h"
23 #include "system/iconv.h"
24 #include "param/param.h"
25
26 /**
27  * @file
28  *
29  * @brief Character-set conversion routines built on our iconv.
30  * 
31  * @note Samba's internal character set (at least in the 3.0 series)
32  * is always the same as the one for the Unix filesystem.  It is
33  * <b>not</b> necessarily UTF-8 and may be different on machines that
34  * need i18n filenames to be compatible with Unix software.  It does
35  * have to be a superset of ASCII.  All multibyte sequences must start
36  * with a byte with the high bit set.
37  *
38  * @sa lib/iconv.c
39  */
40
41 char *unix_charset = NULL;
42 char *dos_charset = NULL;
43 char *display_charset = NULL;
44
45 /**
46  * Return the name of a charset to give to iconv().
47  **/
48 static const char *charset_name(charset_t ch)
49 {
50         switch (ch) {
51         case CH_UTF16: return "UTF-16LE";
52         case CH_UNIX: return unix_charset;
53         case CH_DOS: return dos_charset;
54         case CH_DISPLAY: return display_charset;
55         case CH_UTF8: return "UTF8";
56         case CH_UTF16BE: return "UTF-16BE";
57         default:
58         return "ASCII";
59         }
60 }
61
62 static smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
63
64 /**
65  re-initialize iconv conversion descriptors
66 **/
67 _PUBLIC_ void init_iconv(void)
68 {
69         unsigned c1, c2;
70         for (c1=0;c1<NUM_CHARSETS;c1++) {
71                 for (c2=0;c2<NUM_CHARSETS;c2++) {
72                         if (conv_handles[c1][c2] != NULL) {
73                                 if (conv_handles[c1][c2] != (smb_iconv_t)-1) {
74                                         smb_iconv_close(conv_handles[c1][c2]);
75                                 }
76                                 conv_handles[c1][c2] = NULL;
77                         }
78                 }
79         }
80
81 }
82
83 /*
84   on-demand initialisation of conversion handles
85 */
86 static smb_iconv_t get_conv_handle(charset_t from, charset_t to)
87 {
88         const char *n1, *n2;
89         static int initialised;
90         /* auto-free iconv memory on exit so valgrind reports are easier
91            to look at */
92         if (initialised == 0) {
93                 initialised = 1;
94                 
95 #ifdef LC_ALL
96                 /* we set back the locale to C to get ASCII-compatible
97                    toupper/lower functions.  For now we do not need
98                    any other POSIX localisations anyway. When we
99                    should really need localized string functions one
100                    day we need to write our own ascii_tolower etc.
101                 */
102                 setlocale(LC_ALL, "C");
103 #endif
104
105                 atexit(init_iconv);
106         }
107
108         if (conv_handles[from][to]) {
109                 return conv_handles[from][to];
110         }
111
112         n1 = charset_name(from);
113         n2 = charset_name(to);
114
115         conv_handles[from][to] = smb_iconv_open(n2,n1);
116         
117         if (conv_handles[from][to] == (smb_iconv_t)-1) {
118                 if ((from == CH_DOS || to == CH_DOS) &&
119                     strcasecmp(charset_name(CH_DOS), "ASCII") != 0) {
120                         DEBUG(0,("dos charset '%s' unavailable - using ASCII\n",
121                                  charset_name(CH_DOS)));
122                         lp_set_cmdline("dos charset", "ASCII");
123
124                         n1 = charset_name(from);
125                         n2 = charset_name(to);
126                         
127                         conv_handles[from][to] = smb_iconv_open(n2,n1);
128                 }
129         }
130
131         return conv_handles[from][to];
132 }
133
134
135 /**
136  * Convert string from one encoding to another, making error checking etc
137  *
138  * @param src pointer to source string (multibyte or singlebyte)
139  * @param srclen length of the source string in bytes
140  * @param dest pointer to destination string (multibyte or singlebyte)
141  * @param destlen maximal length allowed for string
142  * @returns the number of bytes occupied in the destination
143  **/
144 _PUBLIC_ ssize_t convert_string(charset_t from, charset_t to,
145                       void const *src, size_t srclen, 
146                       void *dest, size_t destlen)
147 {
148         size_t i_len, o_len;
149         size_t retval;
150         const char* inbuf = (const char*)src;
151         char* outbuf = (char*)dest;
152         smb_iconv_t descriptor;
153
154         if (srclen == (size_t)-1)
155                 srclen = strlen(inbuf)+1;
156
157         descriptor = get_conv_handle(from, to);
158
159         if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
160                 /* conversion not supported, use as is */
161                 size_t len = MIN(srclen,destlen);
162                 memcpy(dest,src,len);
163                 return len;
164         }
165
166         i_len=srclen;
167         o_len=destlen;
168         retval = smb_iconv(descriptor,  &inbuf, &i_len, &outbuf, &o_len);
169         if(retval==(size_t)-1) {
170                 const char *reason;
171                 switch(errno) {
172                         case EINVAL:
173                                 reason="Incomplete multibyte sequence";
174                                 return -1;
175                         case E2BIG:
176                                 reason="No more room"; 
177                                 if (from == CH_UNIX) {
178                                         DEBUG(0,("E2BIG: convert_string(%s,%s): srclen=%d destlen=%d - '%s'\n",
179                                                  charset_name(from), charset_name(to),
180                                                  (int)srclen, (int)destlen, 
181                                                  (const char *)src));
182                                 } else {
183                                         DEBUG(0,("E2BIG: convert_string(%s,%s): srclen=%d destlen=%d\n",
184                                                  charset_name(from), charset_name(to),
185                                                  (int)srclen, (int)destlen));
186                                 }
187                                return -1;
188                         case EILSEQ:
189                                reason="Illegal multibyte sequence";
190                                return -1;
191                 }
192                 /* smb_panic(reason); */
193         }
194         return destlen-o_len;
195 }
196
197 /**
198  * Convert between character sets, allocating a new buffer using talloc for the result.
199  *
200  * @param srclen length of source buffer.
201  * @param dest always set at least to NULL
202  * @note -1 is not accepted for srclen.
203  *
204  * @returns Size in bytes of the converted string; or -1 in case of error.
205  **/
206
207 _PUBLIC_ ssize_t convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
208                               void const *src, size_t srclen, void **dest)
209 {
210         size_t i_len, o_len, destlen;
211         size_t retval;
212         const char *inbuf = (const char *)src;
213         char *outbuf, *ob;
214         smb_iconv_t descriptor;
215
216         *dest = NULL;
217
218         if (src == NULL || srclen == (size_t)-1 || srclen == 0)
219                 return (size_t)-1;
220
221         descriptor = get_conv_handle(from, to);
222
223         if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
224                 /* conversion not supported, return -1*/
225                 DEBUG(3, ("convert_string_talloc: conversion from %s to %s not supported!\n",
226                           charset_name(from), charset_name(to)));
227                 return -1;
228         }
229
230         /* it is _very_ rare that a conversion increases the size by
231            more than 3x */
232         destlen = srclen;
233         outbuf = NULL;
234 convert:
235         destlen = 2 + (destlen*3);
236         ob = talloc_realloc(ctx, outbuf, char, destlen);
237         if (!ob) {
238                 DEBUG(0, ("convert_string_talloc: realloc failed!\n"));
239                 talloc_free(outbuf);
240                 return (size_t)-1;
241         } else {
242                 outbuf = ob;
243         }
244
245         /* we give iconv 2 less bytes to allow us to terminate at the
246            end */
247         i_len = srclen;
248         o_len = destlen-2;
249         retval = smb_iconv(descriptor,
250                            &inbuf, &i_len,
251                            &outbuf, &o_len);
252         if(retval == (size_t)-1)                {
253                 const char *reason="unknown error";
254                 switch(errno) {
255                         case EINVAL:
256                                 reason="Incomplete multibyte sequence";
257                                 break;
258                         case E2BIG:
259                                 goto convert;           
260                         case EILSEQ:
261                                 reason="Illegal multibyte sequence";
262                                 break;
263                 }
264                 DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
265                 talloc_free(ob);
266                 return (size_t)-1;
267         }
268         
269         destlen = (destlen-2) - o_len;
270
271         /* guarantee null termination in all charsets */
272         SSVAL(ob, destlen, 0);
273
274         *dest = ob;
275
276         return destlen;
277 }
278
279 /**
280  * Copy a string from a char* unix src to a dos codepage string destination.
281  *
282  * @return the number of bytes occupied by the string in the destination.
283  *
284  * @param flags can include
285  * <dl>
286  * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
287  * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
288  * </dl>
289  *
290  * @param dest_len the maximum length in bytes allowed in the
291  * destination.  If @p dest_len is -1 then no maximum is used.
292  **/
293 static ssize_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
294 {
295         size_t src_len;
296         ssize_t ret;
297
298         if (flags & STR_UPPER) {
299                 char *tmpbuf = strupper_talloc(NULL, src);
300                 if (tmpbuf == NULL) {
301                         return -1;
302                 }
303                 ret = push_ascii(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
304                 talloc_free(tmpbuf);
305                 return ret;
306         }
307
308         src_len = strlen(src);
309
310         if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
311                 src_len++;
312
313         return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len);
314 }
315
316 /**
317  * Copy a string from a unix char* src to an ASCII destination,
318  * allocating a buffer using talloc().
319  *
320  * @param dest always set at least to NULL 
321  *
322  * @returns The number of bytes occupied by the string in the destination
323  *         or -1 in case of error.
324  **/
325 _PUBLIC_ ssize_t push_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
326 {
327         size_t src_len = strlen(src)+1;
328         *dest = NULL;
329         return convert_string_talloc(ctx, CH_UNIX, CH_DOS, src, src_len, (void **)dest);
330 }
331
332
333 /**
334  * Copy a string from a dos codepage source to a unix char* destination.
335  *
336  * The resulting string in "dest" is always null terminated.
337  *
338  * @param flags can have:
339  * <dl>
340  * <dt>STR_TERMINATE</dt>
341  * <dd>STR_TERMINATE means the string in @p src
342  * is null terminated, and src_len is ignored.</dd>
343  * </dl>
344  *
345  * @param src_len is the length of the source area in bytes.
346  * @returns the number of bytes occupied by the string in @p src.
347  **/
348 static ssize_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
349 {
350         size_t ret;
351
352         if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
353                 if (src_len == (size_t)-1) {
354                         src_len = strlen((const char *)src) + 1;
355                 } else {
356                         size_t len = strnlen((const char *)src, src_len);
357                         if (len < src_len)
358                                 len++;
359                         src_len = len;
360                 }
361         }
362
363         ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len);
364
365         if (dest_len)
366                 dest[MIN(ret, dest_len-1)] = 0;
367
368         return src_len;
369 }
370
371 /**
372  * Copy a string from a char* src to a unicode destination.
373  *
374  * @returns the number of bytes occupied by the string in the destination.
375  *
376  * @param flags can have:
377  *
378  * <dl>
379  * <dt>STR_TERMINATE <dd>means include the null termination.
380  * <dt>STR_UPPER     <dd>means uppercase in the destination.
381  * <dt>STR_NOALIGN   <dd>means don't do alignment.
382  * </dl>
383  *
384  * @param dest_len is the maximum length allowed in the
385  * destination. If dest_len is -1 then no maxiumum is used.
386  **/
387 static ssize_t push_ucs2(void *dest, const char *src, size_t dest_len, int flags)
388 {
389         size_t len=0;
390         size_t src_len = strlen(src);
391         size_t ret;
392
393         if (flags & STR_UPPER) {
394                 char *tmpbuf = strupper_talloc(NULL, src);
395                 if (tmpbuf == NULL) {
396                         return -1;
397                 }
398                 ret = push_ucs2(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
399                 talloc_free(tmpbuf);
400                 return ret;
401         }
402
403         if (flags & STR_TERMINATE)
404                 src_len++;
405
406         if (ucs2_align(NULL, dest, flags)) {
407                 *(char *)dest = 0;
408                 dest = (void *)((char *)dest + 1);
409                 if (dest_len) dest_len--;
410                 len++;
411         }
412
413         /* ucs2 is always a multiple of 2 bytes */
414         dest_len &= ~1;
415
416         ret = convert_string(CH_UNIX, CH_UTF16, src, src_len, dest, dest_len);
417         if (ret == (size_t)-1) {
418                 return 0;
419         }
420
421         len += ret;
422
423         return len;
424 }
425
426
427 /**
428  * Copy a string from a unix char* src to a UCS2 destination,
429  * allocating a buffer using talloc().
430  *
431  * @param dest always set at least to NULL 
432  *
433  * @returns The number of bytes occupied by the string in the destination
434  *         or -1 in case of error.
435  **/
436 _PUBLIC_ ssize_t push_ucs2_talloc(TALLOC_CTX *ctx, void **dest, const char *src)
437 {
438         size_t src_len = strlen(src)+1;
439         *dest = NULL;
440         return convert_string_talloc(ctx, CH_UNIX, CH_UTF16, src, src_len, dest);
441 }
442
443
444 /**
445  * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
446  *
447  * @param dest always set at least to NULL 
448  *
449  * @returns The number of bytes occupied by the string in the destination
450  **/
451
452 _PUBLIC_ ssize_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
453 {
454         size_t src_len = strlen(src)+1;
455         *dest = NULL;
456         return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void **)dest);
457 }
458
459 /**
460  Copy a string from a ucs2 source to a unix char* destination.
461  Flags can have:
462   STR_TERMINATE means the string in src is null terminated.
463   STR_NOALIGN   means don't try to align.
464  if STR_TERMINATE is set then src_len is ignored if it is -1.
465  src_len is the length of the source area in bytes
466  Return the number of bytes occupied by the string in src.
467  The resulting string in "dest" is always null terminated.
468 **/
469
470 static size_t pull_ucs2(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
471 {
472         size_t ret;
473
474         if (ucs2_align(NULL, src, flags)) {
475                 src = (const void *)((const char *)src + 1);
476                 if (src_len > 0)
477                         src_len--;
478         }
479
480         if (flags & STR_TERMINATE) {
481                 if (src_len == (size_t)-1) {
482                         src_len = utf16_len(src);
483                 } else {
484                         src_len = utf16_len_n(src, src_len);
485                 }
486         }
487
488         /* ucs2 is always a multiple of 2 bytes */
489         if (src_len != (size_t)-1)
490                 src_len &= ~1;
491         
492         ret = convert_string(CH_UTF16, CH_UNIX, src, src_len, dest, dest_len);
493         if (dest_len)
494                 dest[MIN(ret, dest_len-1)] = 0;
495
496         return src_len;
497 }
498
499 /**
500  * Copy a string from a ASCII src to a unix char * destination, allocating a buffer using talloc
501  *
502  * @param dest always set at least to NULL 
503  *
504  * @returns The number of bytes occupied by the string in the destination
505  **/
506
507 _PUBLIC_ ssize_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
508 {
509         size_t src_len = strlen(src)+1;
510         *dest = NULL;
511         return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest);
512 }
513
514 /**
515  * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
516  *
517  * @param dest always set at least to NULL 
518  *
519  * @returns The number of bytes occupied by the string in the destination
520  **/
521
522 _PUBLIC_ ssize_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const void *src)
523 {
524         size_t src_len = utf16_len(src);
525         *dest = NULL;
526         return convert_string_talloc(ctx, CH_UTF16, CH_UNIX, src, src_len, (void **)dest);
527 }
528
529 /**
530  * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
531  *
532  * @param dest always set at least to NULL 
533  *
534  * @returns The number of bytes occupied by the string in the destination
535  **/
536
537 _PUBLIC_ ssize_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
538 {
539         size_t src_len = strlen(src)+1;
540         *dest = NULL;
541         return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest);
542 }
543
544 /**
545  Copy a string from a char* src to a unicode or ascii
546  dos codepage destination choosing unicode or ascii based on the 
547  flags in the SMB buffer starting at base_ptr.
548  Return the number of bytes occupied by the string in the destination.
549  flags can have:
550   STR_TERMINATE means include the null termination.
551   STR_UPPER     means uppercase in the destination.
552   STR_ASCII     use ascii even with unicode packet.
553   STR_NOALIGN   means don't do alignment.
554  dest_len is the maximum length allowed in the destination. If dest_len
555  is -1 then no maxiumum is used.
556 **/
557
558 _PUBLIC_ ssize_t push_string(void *dest, const char *src, size_t dest_len, int flags)
559 {
560         if (flags & STR_ASCII) {
561                 return push_ascii(dest, src, dest_len, flags);
562         } else if (flags & STR_UNICODE) {
563                 return push_ucs2(dest, src, dest_len, flags);
564         } else {
565                 smb_panic("push_string requires either STR_ASCII or STR_UNICODE flag to be set");
566                 return -1;
567         }
568 }
569
570
571 /**
572  Copy a string from a unicode or ascii source (depending on
573  the packet flags) to a char* destination.
574  Flags can have:
575   STR_TERMINATE means the string in src is null terminated.
576   STR_UNICODE   means to force as unicode.
577   STR_ASCII     use ascii even with unicode packet.
578   STR_NOALIGN   means don't do alignment.
579  if STR_TERMINATE is set then src_len is ignored is it is -1
580  src_len is the length of the source area in bytes.
581  Return the number of bytes occupied by the string in src.
582  The resulting string in "dest" is always null terminated.
583 **/
584
585 _PUBLIC_ ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
586 {
587         if (flags & STR_ASCII) {
588                 return pull_ascii(dest, src, dest_len, src_len, flags);
589         } else if (flags & STR_UNICODE) {
590                 return pull_ucs2(dest, src, dest_len, src_len, flags);
591         } else {
592                 smb_panic("pull_string requires either STR_ASCII or STR_UNICODE flag to be set");
593                 return -1;
594         }
595 }
596
597
598 /*
599   return the unicode codepoint for the next multi-byte CH_UNIX character
600   in the string
601
602   also return the number of bytes consumed (which tells the caller
603   how many bytes to skip to get to the next CH_UNIX character)
604
605   return INVALID_CODEPOINT if the next character cannot be converted
606 */
607 _PUBLIC_ codepoint_t next_codepoint(const char *str, size_t *size)
608 {
609         /* it cannot occupy more than 4 bytes in UTF16 format */
610         uint8_t buf[4];
611         smb_iconv_t descriptor;
612         size_t ilen_orig;
613         size_t ilen;
614         size_t olen;
615         char *outbuf;
616
617         if ((str[0] & 0x80) == 0) {
618                 *size = 1;
619                 return (codepoint_t)str[0];
620         }
621
622         /* we assume that no multi-byte character can take
623            more than 5 bytes. This is OK as we only
624            support codepoints up to 1M */
625         ilen_orig = strnlen(str, 5);
626         ilen = ilen_orig;
627
628         descriptor = get_conv_handle(CH_UNIX, CH_UTF16);
629         if (descriptor == (smb_iconv_t)-1) {
630                 *size = 1;
631                 return INVALID_CODEPOINT;
632         }
633
634         /* this looks a little strange, but it is needed to cope
635            with codepoints above 64k */
636         olen = 2;
637         outbuf = (char *)buf;
638         smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
639         if (olen == 2) {
640                 olen = 4;
641                 outbuf = (char *)buf;
642                 smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
643                 if (olen == 4) {
644                         /* we didn't convert any bytes */
645                         *size = 1;
646                         return INVALID_CODEPOINT;
647                 }
648                 olen = 4 - olen;
649         } else {
650                 olen = 2 - olen;
651         }
652
653         *size = ilen_orig - ilen;
654
655         if (olen == 2) {
656                 return (codepoint_t)SVAL(buf, 0);
657         }
658         if (olen == 4) {
659                 /* decode a 4 byte UTF16 character manually */
660                 return (codepoint_t)0x10000 + 
661                         (buf[2] | ((buf[3] & 0x3)<<8) | 
662                          (buf[0]<<10) | ((buf[1] & 0x3)<<18));
663         }
664
665         /* no other length is valid */
666         return INVALID_CODEPOINT;
667 }
668
669 /*
670   push a single codepoint into a CH_UNIX string the target string must
671   be able to hold the full character, which is guaranteed if it is at
672   least 5 bytes in size. The caller may pass less than 5 bytes if they
673   are sure the character will fit (for example, you can assume that
674   uppercase/lowercase of a character will not add more than 1 byte)
675
676   return the number of bytes occupied by the CH_UNIX character, or
677   -1 on failure
678 */
679 _PUBLIC_ ssize_t push_codepoint(char *str, codepoint_t c)
680 {
681         smb_iconv_t descriptor;
682         uint8_t buf[4];
683         size_t ilen, olen;
684         const char *inbuf;
685         
686         if (c < 128) {
687                 *str = c;
688                 return 1;
689         }
690
691         descriptor = get_conv_handle(CH_UTF16, CH_UNIX);
692         if (descriptor == (smb_iconv_t)-1) {
693                 return -1;
694         }
695
696         if (c < 0x10000) {
697                 ilen = 2;
698                 olen = 5;
699                 inbuf = (char *)buf;
700                 SSVAL(buf, 0, c);
701                 smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
702                 if (ilen != 0) {
703                         return -1;
704                 }
705                 return 5 - olen;
706         }
707
708         c -= 0x10000;
709
710         buf[0] = (c>>10) & 0xFF;
711         buf[1] = (c>>18) | 0xd8;
712         buf[2] = c & 0xFF;
713         buf[3] = ((c>>8) & 0x3) | 0xdc;
714
715         ilen = 4;
716         olen = 5;
717         inbuf = (char *)buf;
718
719         smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
720         if (ilen != 0) {
721                 return -1;
722         }
723         return 5 - olen;
724 }