1 /* gzio.c -- IO on .gz files
2 * Copyright (C) 1995-2002 Jean-loup Gailly.
3 * For conditions of distribution and use, see copyright notice in zlib.h
5 * Compile this file with -DNO_DEFLATE to avoid the compression code.
7 * $FreeBSD: src/lib/libz/gzio.c,v 1.5.2.3 2003/04/12 20:23:25 jmz Exp $
8 * $DragonFly: src/lib/libz/Attic/gzio.c,v 1.2 2003/06/17 04:26:52 dillon Exp $
15 struct internal_state {int dummy;}; /* for buggy compilers */
19 # define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
21 # define Z_BUFSIZE 16384
24 #ifndef Z_PRINTF_BUFSIZE
25 # define Z_PRINTF_BUFSIZE 4096
28 #define ALLOC(size) malloc(size)
29 #define TRYFREE(p) {if (p) free(p);}
31 static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
34 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
35 #define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
36 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
37 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
38 #define COMMENT 0x10 /* bit 4 set: file comment present */
39 #define RESERVED 0xE0 /* bits 5..7: reserved */
41 typedef struct gz_stream {
43 int z_err; /* error code for last stream operation */
44 int z_eof; /* set if end of input file */
45 FILE *file; /* .gz file */
46 Byte *inbuf; /* input buffer */
47 Byte *outbuf; /* output buffer */
48 uLong crc; /* crc32 of uncompressed data */
49 char *msg; /* error message */
50 char *path; /* path name for debugging only */
51 int transparent; /* 1 if input file is not a .gz file */
52 char mode; /* 'w' or 'r' */
53 long startpos; /* start of compressed data in file (header skipped) */
57 local gzFile gz_open OF((const char *path, const char *mode, int fd));
58 local int do_flush OF((gzFile file, int flush));
59 local int get_byte OF((gz_stream *s));
60 local void check_header OF((gz_stream *s));
61 local int destroy OF((gz_stream *s));
62 local void putLong OF((FILE *file, uLong x));
63 local uLong getLong OF((gz_stream *s));
65 /* ===========================================================================
66 Opens a gzip (.gz) file for reading or writing. The mode parameter
67 is as in fopen ("rb" or "wb"). The file is given either by file descriptor
68 or path name (if fd == -1).
69 gz_open return NULL if the file could not be opened or if there was
70 insufficient memory to allocate the (de)compression state; errno
71 can be checked to distinguish the two cases (if errno is zero, the
72 zlib error is Z_MEM_ERROR).
74 local gzFile gz_open (path, mode, fd)
80 int level = Z_DEFAULT_COMPRESSION; /* compression level */
81 int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
82 char *p = (char*)mode;
84 char fmode[80]; /* copy of mode, without the compression level */
87 if (!path || !mode) return Z_NULL;
89 s = (gz_stream *)ALLOC(sizeof(gz_stream));
90 if (!s) return Z_NULL;
92 s->stream.zalloc = (alloc_func)0;
93 s->stream.zfree = (free_func)0;
94 s->stream.opaque = (voidpf)0;
95 s->stream.next_in = s->inbuf = Z_NULL;
96 s->stream.next_out = s->outbuf = Z_NULL;
97 s->stream.avail_in = s->stream.avail_out = 0;
101 s->crc = crc32(0L, Z_NULL, 0);
105 s->path = (char*)ALLOC(strlen(path)+1);
106 if (s->path == NULL) {
107 return destroy(s), (gzFile)Z_NULL;
109 strcpy(s->path, path); /* do this early for debugging */
113 if (*p == 'r') s->mode = 'r';
114 if (*p == 'w' || *p == 'a') s->mode = 'w';
115 if (*p >= '0' && *p <= '9') {
117 } else if (*p == 'f') {
118 strategy = Z_FILTERED;
119 } else if (*p == 'h') {
120 strategy = Z_HUFFMAN_ONLY;
122 *m++ = *p; /* copy the mode */
124 } while (*p++ && m != fmode + sizeof(fmode));
125 if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
127 if (s->mode == 'w') {
129 err = Z_STREAM_ERROR;
131 err = deflateInit2(&(s->stream), level,
132 Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
133 /* windowBits is passed < 0 to suppress zlib header */
135 s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
137 if (err != Z_OK || s->outbuf == Z_NULL) {
138 return destroy(s), (gzFile)Z_NULL;
141 s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
143 err = inflateInit2(&(s->stream), -MAX_WBITS);
144 /* windowBits is passed < 0 to tell that there is no zlib header.
145 * Note that in this case inflate *requires* an extra "dummy" byte
146 * after the compressed stream in order to complete decompression and
147 * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
148 * present after the compressed stream.
150 if (err != Z_OK || s->inbuf == Z_NULL) {
151 return destroy(s), (gzFile)Z_NULL;
154 s->stream.avail_out = Z_BUFSIZE;
157 s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
159 if (s->file == NULL) {
160 return destroy(s), (gzFile)Z_NULL;
162 if (s->mode == 'w') {
163 /* Write a very simple .gz header:
165 fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
166 Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
168 /* We use 10L instead of ftell(s->file) to because ftell causes an
169 * fflush on some systems. This version of the library doesn't use
170 * startpos anyway in write mode, so this initialization is not
174 check_header(s); /* skip the .gz header */
175 s->startpos = (ftell(s->file) - s->stream.avail_in);
181 /* ===========================================================================
182 Opens a gzip (.gz) file for reading or writing.
184 gzFile ZEXPORT gzopen (path, mode)
188 return gz_open (path, mode, -1);
191 /* ===========================================================================
192 Associate a gzFile with the file descriptor fd. fd is not dup'ed here
193 to mimic the behavio(u)r of fdopen.
195 gzFile ZEXPORT gzdopen (fd, mode)
201 if (fd < 0) return (gzFile)Z_NULL;
202 snprintf(name, sizeof(name), "<fd:%d>", fd); /* for debugging */
204 return gz_open (name, mode, fd);
207 /* ===========================================================================
208 * Update the compression level and strategy
210 int ZEXPORT gzsetparams (file, level, strategy)
215 gz_stream *s = (gz_stream*)file;
217 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
219 /* Make room to allow flushing */
220 if (s->stream.avail_out == 0) {
222 s->stream.next_out = s->outbuf;
223 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
226 s->stream.avail_out = Z_BUFSIZE;
229 return deflateParams (&(s->stream), level, strategy);
232 /* ===========================================================================
233 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
235 IN assertion: the stream s has been sucessfully opened for reading.
237 local int get_byte(s)
240 if (s->z_eof) return EOF;
241 if (s->stream.avail_in == 0) {
243 s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
244 if (s->stream.avail_in == 0) {
246 if (ferror(s->file)) s->z_err = Z_ERRNO;
249 s->stream.next_in = s->inbuf;
251 s->stream.avail_in--;
252 return *(s->stream.next_in)++;
255 /* ===========================================================================
256 Check the gzip header of a gz_stream opened for reading. Set the stream
257 mode to transparent if the gzip magic header is not present; set s->err
258 to Z_DATA_ERROR if the magic header is present but the rest of the header
260 IN assertion: the stream s has already been created sucessfully;
261 s->stream.avail_in is zero for the first time, but may be non-zero
262 for concatenated .gz files.
264 local void check_header(s)
267 int method; /* method byte */
268 int flags; /* flags byte */
272 /* Check the gzip magic header */
273 for (len = 0; len < 2; len++) {
275 if (c != gz_magic[len]) {
276 if (len != 0) s->stream.avail_in++, s->stream.next_in--;
278 s->stream.avail_in++, s->stream.next_in--;
281 s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END;
285 method = get_byte(s);
287 if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
288 s->z_err = Z_DATA_ERROR;
292 /* Discard time, xflags and OS code: */
293 for (len = 0; len < 6; len++) (void)get_byte(s);
295 if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
296 len = (uInt)get_byte(s);
297 len += ((uInt)get_byte(s))<<8;
298 /* len is garbage if EOF but the loop below will quit anyway */
299 while (len-- != 0 && get_byte(s) != EOF) ;
301 if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
302 while ((c = get_byte(s)) != 0 && c != EOF) ;
304 if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
305 while ((c = get_byte(s)) != 0 && c != EOF) ;
307 if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
308 for (len = 0; len < 2; len++) (void)get_byte(s);
310 s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
313 /* ===========================================================================
314 * Cleanup then free the given gz_stream. Return a zlib error code.
315 Try freeing in the reverse order of allocations.
317 local int destroy (s)
322 if (!s) return Z_STREAM_ERROR;
326 if (s->stream.state != NULL) {
327 if (s->mode == 'w') {
329 err = Z_STREAM_ERROR;
331 err = deflateEnd(&(s->stream));
333 } else if (s->mode == 'r') {
334 err = inflateEnd(&(s->stream));
337 if (s->file != NULL && fclose(s->file)) {
339 if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
343 if (s->z_err < 0) err = s->z_err;
352 /* ===========================================================================
353 Reads the given number of uncompressed bytes from the compressed file.
354 gzread returns the number of bytes actually read (0 for end of file).
356 int ZEXPORT gzread (file, buf, len)
361 gz_stream *s = (gz_stream*)file;
362 Bytef *start = (Bytef*)buf; /* starting point for crc computation */
363 Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
365 if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
367 if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
368 if (s->z_err == Z_STREAM_END) return 0; /* EOF */
370 next_out = (Byte*)buf;
371 s->stream.next_out = (Bytef*)buf;
372 s->stream.avail_out = len;
374 while (s->stream.avail_out != 0) {
376 if (s->transparent) {
377 /* Copy first the lookahead bytes: */
378 uInt n = s->stream.avail_in;
379 if (n > s->stream.avail_out) n = s->stream.avail_out;
381 zmemcpy(s->stream.next_out, s->stream.next_in, n);
383 s->stream.next_out = next_out;
384 s->stream.next_in += n;
385 s->stream.avail_out -= n;
386 s->stream.avail_in -= n;
388 if (s->stream.avail_out > 0) {
389 s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out,
392 len -= s->stream.avail_out;
393 s->stream.total_in += (uLong)len;
394 s->stream.total_out += (uLong)len;
395 if (len == 0) s->z_eof = 1;
398 if (s->stream.avail_in == 0 && !s->z_eof) {
401 s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file);
402 if (s->stream.avail_in == 0) {
404 if (ferror(s->file)) {
409 s->stream.next_in = s->inbuf;
411 s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
413 if (s->z_err == Z_STREAM_END) {
414 /* Check CRC and original size */
415 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
416 start = s->stream.next_out;
418 if (getLong(s) != s->crc) {
419 s->z_err = Z_DATA_ERROR;
422 /* The uncompressed length returned by above getlong() may
423 * be different from s->stream.total_out) in case of
424 * concatenated .gz files. Check for such files:
427 if (s->z_err == Z_OK) {
428 uLong total_in = s->stream.total_in;
429 uLong total_out = s->stream.total_out;
431 inflateReset(&(s->stream));
432 s->stream.total_in = total_in;
433 s->stream.total_out = total_out;
434 s->crc = crc32(0L, Z_NULL, 0);
438 if (s->z_err != Z_OK || s->z_eof) break;
440 s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
442 return (int)(len - s->stream.avail_out);
446 /* ===========================================================================
447 Reads one byte from the compressed file. gzgetc returns this byte
448 or -1 in case of end of file or error.
450 int ZEXPORT gzgetc(file)
455 return gzread(file, &c, 1) == 1 ? c : -1;
459 /* ===========================================================================
460 Reads bytes from the compressed file until len-1 characters are
461 read, or a newline character is read and transferred to buf, or an
462 end-of-file condition is encountered. The string is then terminated
463 with a null character.
464 gzgets returns buf, or Z_NULL in case of error.
466 The current implementation is not optimized at all.
468 char * ZEXPORT gzgets(file, buf, len)
474 if (buf == Z_NULL || len <= 0) return Z_NULL;
476 while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
478 return b == buf && len > 0 ? Z_NULL : b;
483 /* ===========================================================================
484 Writes the given number of uncompressed bytes into the compressed file.
485 gzwrite returns the number of bytes actually written (0 in case of error).
487 int ZEXPORT gzwrite (file, buf, len)
492 gz_stream *s = (gz_stream*)file;
494 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
496 s->stream.next_in = (Bytef*)buf;
497 s->stream.avail_in = len;
499 while (s->stream.avail_in != 0) {
501 if (s->stream.avail_out == 0) {
503 s->stream.next_out = s->outbuf;
504 if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
508 s->stream.avail_out = Z_BUFSIZE;
510 s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
511 if (s->z_err != Z_OK) break;
513 s->crc = crc32(s->crc, (const Bytef *)buf, len);
515 return (int)(len - s->stream.avail_in);
518 /* ===========================================================================
519 Converts, formats, and writes the args to the compressed file under
520 control of the format string, as in fprintf. gzprintf returns the number of
521 uncompressed bytes actually written (0 in case of error).
526 int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
528 char buf[Z_PRINTF_BUFSIZE];
532 va_start(va, format);
534 len = vsnprintf(buf, sizeof(buf), format, va);
536 len = vsprintf(buf, format, va);
539 if (len <= 0 || len >= sizeof(buf)) return 0;
541 return gzwrite(file, buf, (unsigned)len);
543 #else /* not ANSI C */
545 int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
546 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
549 int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
550 a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
552 char buf[Z_PRINTF_BUFSIZE];
556 len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
557 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
559 sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
560 a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
561 len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */
563 if (len <= 0 || len >= sizeof(buf)) return 0;
565 return gzwrite(file, buf, len);
569 /* ===========================================================================
570 Writes c, converted to an unsigned char, into the compressed file.
571 gzputc returns the value that was written, or -1 in case of error.
573 int ZEXPORT gzputc(file, c)
577 unsigned char cc = (unsigned char) c; /* required for big endian systems */
579 return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
583 /* ===========================================================================
584 Writes the given null-terminated string to the compressed file, excluding
585 the terminating null character.
586 gzputs returns the number of characters written, or -1 in case of error.
588 int ZEXPORT gzputs(file, s)
592 return gzwrite(file, (char*)s, (unsigned)strlen(s));
596 /* ===========================================================================
597 Flushes all pending output into the compressed file. The parameter
598 flush is as in the deflate() function.
600 local int do_flush (file, flush)
606 gz_stream *s = (gz_stream*)file;
608 if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
610 s->stream.avail_in = 0; /* should be zero already anyway */
613 len = Z_BUFSIZE - s->stream.avail_out;
616 if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
620 s->stream.next_out = s->outbuf;
621 s->stream.avail_out = Z_BUFSIZE;
624 s->z_err = deflate(&(s->stream), flush);
626 /* Ignore the second of two consecutive flushes: */
627 if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
629 /* deflate has finished flushing only when it hasn't used up
630 * all the available space in the output buffer:
632 done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
634 if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
636 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
639 int ZEXPORT gzflush (file, flush)
643 gz_stream *s = (gz_stream*)file;
644 int err = do_flush (file, flush);
648 return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
650 #endif /* NO_DEFLATE */
652 /* ===========================================================================
653 Sets the starting position for the next gzread or gzwrite on the given
654 compressed file. The offset represents a number of bytes in the
655 gzseek returns the resulting offset location as measured in bytes from
656 the beginning of the uncompressed stream, or -1 in case of error.
657 SEEK_END is not implemented, returns error.
658 In this version of the library, gzseek can be extremely slow.
660 z_off_t ZEXPORT gzseek (file, offset, whence)
665 gz_stream *s = (gz_stream*)file;
667 if (s == NULL || whence == SEEK_END ||
668 s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
672 if (s->mode == 'w') {
676 if (whence == SEEK_SET) {
677 offset -= s->stream.total_in;
679 if (offset < 0) return -1L;
681 /* At this point, offset is the number of zero bytes to write. */
682 if (s->inbuf == Z_NULL) {
683 s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
684 zmemzero(s->inbuf, Z_BUFSIZE);
687 uInt size = Z_BUFSIZE;
688 if (offset < Z_BUFSIZE) size = (uInt)offset;
690 size = gzwrite(file, s->inbuf, size);
691 if (size == 0) return -1L;
695 return (z_off_t)s->stream.total_in;
698 /* Rest of function is for reading only */
700 /* compute absolute position */
701 if (whence == SEEK_CUR) {
702 offset += s->stream.total_out;
704 if (offset < 0) return -1L;
706 if (s->transparent) {
708 s->stream.avail_in = 0;
709 s->stream.next_in = s->inbuf;
710 if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
712 s->stream.total_in = s->stream.total_out = (uLong)offset;
716 /* For a negative seek, rewind and use positive seek */
717 if ((uLong)offset >= s->stream.total_out) {
718 offset -= s->stream.total_out;
719 } else if (gzrewind(file) < 0) {
722 /* offset is now the number of bytes to skip. */
724 if (offset != 0 && s->outbuf == Z_NULL) {
725 s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
728 int size = Z_BUFSIZE;
729 if (offset < Z_BUFSIZE) size = (int)offset;
731 size = gzread(file, s->outbuf, (uInt)size);
732 if (size <= 0) return -1L;
735 return (z_off_t)s->stream.total_out;
738 /* ===========================================================================
741 int ZEXPORT gzrewind (file)
744 gz_stream *s = (gz_stream*)file;
746 if (s == NULL || s->mode != 'r') return -1;
750 s->stream.avail_in = 0;
751 s->stream.next_in = s->inbuf;
752 s->crc = crc32(0L, Z_NULL, 0);
754 if (s->startpos == 0) { /* not a compressed file */
759 (void) inflateReset(&s->stream);
760 return fseek(s->file, s->startpos, SEEK_SET);
763 /* ===========================================================================
764 Returns the starting position for the next gzread or gzwrite on the
765 given compressed file. This position represents a number of bytes in the
766 uncompressed data stream.
768 z_off_t ZEXPORT gztell (file)
771 return gzseek(file, 0L, SEEK_CUR);
774 /* ===========================================================================
775 Returns 1 when EOF has previously been detected reading the given
776 input stream, otherwise zero.
778 int ZEXPORT gzeof (file)
781 gz_stream *s = (gz_stream*)file;
783 return (s == NULL || s->mode != 'r') ? 0 : s->z_eof;
786 /* ===========================================================================
787 Outputs a long in LSB order to the given file
789 local void putLong (file, x)
794 for (n = 0; n < 4; n++) {
795 fputc((int)(x & 0xff), file);
800 /* ===========================================================================
801 Reads a long in LSB order from the given gz_stream. Sets z_err in case
804 local uLong getLong (s)
807 uLong x = (uLong)get_byte(s);
810 x += ((uLong)get_byte(s))<<8;
811 x += ((uLong)get_byte(s))<<16;
813 if (c == EOF) s->z_err = Z_DATA_ERROR;
818 /* ===========================================================================
819 Flushes all pending output if necessary, closes the compressed file
820 and deallocates all the (de)compression state.
822 int ZEXPORT gzclose (file)
826 gz_stream *s = (gz_stream*)file;
828 if (s == NULL) return Z_STREAM_ERROR;
830 if (s->mode == 'w') {
832 return Z_STREAM_ERROR;
834 err = do_flush (file, Z_FINISH);
835 if (err != Z_OK) return destroy((gz_stream*)file);
837 putLong (s->file, s->crc);
838 putLong (s->file, s->stream.total_in);
841 return destroy((gz_stream*)file);
844 /* ===========================================================================
845 Returns the error message for the last error which occured on the
846 given compressed file. errnum is set to zlib error number. If an
847 error occured in the file system and not in the compression library,
848 errnum is set to Z_ERRNO and the application may consult errno
849 to get the exact error code.
851 const char* ZEXPORT gzerror (file, errnum)
856 gz_stream *s = (gz_stream*)file;
859 *errnum = Z_STREAM_ERROR;
860 return (const char*)ERR_MSG(Z_STREAM_ERROR);
863 if (*errnum == Z_OK) return (const char*)"";
865 m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
867 if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
870 s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
871 strcpy(s->msg, s->path);
872 strcat(s->msg, ": ");
874 return (const char*)s->msg;