← Back to branch summary

~ubuntu-branches/ubuntu/lucid/mysql-dfsg-5.1/lucid-security

« back to all changes in this revision

Viewing changes to cmd-line-utils/libedit/el.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2012-02-22 22:33:55 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120222223355-or06x1euyk8n0ldi
Tags: 5.1.61-0ubuntu0.10.04.1
https://launchpad.net/bugs/937869
* SECURITY UPDATE: Update to 5.1.61 to fix multiple security issues
  (LP: #937869)
  - http://www.oracle.com/technetwork/topics/security/cpujan2012-366304.html
  - CVE-2011-2262
  - CVE-2012-0075
  - CVE-2012-0112
  - CVE-2012-0113
  - CVE-2012-0114
  - CVE-2012-0115
  - CVE-2012-0116
  - CVE-2012-0117
  - CVE-2012-0118
  - CVE-2012-0119
  - CVE-2012-0120
  - CVE-2012-0484
  - CVE-2012-0485
  - CVE-2012-0486
  - CVE-2012-0487
  - CVE-2012-0488
  - CVE-2012-0489
  - CVE-2012-0490
  - CVE-2012-0491
  - CVE-2012-0492
  - CVE-2012-0493
  - CVE-2012-0494
  - CVE-2012-0495
  - CVE-2012-0496
* Dropped patches unnecessary with 5.1.61:
  - debian/patches/90_mysql_safer_strmov.dpatch
  - debian/patches/51_ssl_test_certs.dpatch
  - debian/patches/52_CVE-2009-4030.dpatch
  - debian/patches/53_CVE-2009-4484.dpatch
  - debian/patches/54_CVE-2008-7247.dpatch
  - debian/patches/55_CVE-2010-1621.dpatch
  - debian/patches/56_CVE-2010-1850.dpatch
  - debian/patches/57_CVE-2010-1849.dpatch
  - debian/patches/58_CVE-2010-1848.dpatch
  - debian/patches/59_CVE-2010-1626.dpatch
  - debian/patches/60_CVE-2010-2008.dpatch
  - debian/patches/60_CVE-2010-3677.dpatch
  - debian/patches/60_CVE-2010-3678.dpatch
  - debian/patches/60_CVE-2010-3679.dpatch
  - debian/patches/60_CVE-2010-3680.dpatch
  - debian/patches/60_CVE-2010-3681.dpatch
  - debian/patches/60_CVE-2010-3682.dpatch
  - debian/patches/60_CVE-2010-3683.dpatch
  - debian/patches/60_CVE-2010-3833.dpatch
  - debian/patches/60_CVE-2010-3834.dpatch
  - debian/patches/60_CVE-2010-3835.dpatch
  - debian/patches/60_CVE-2010-3836.dpatch
  - debian/patches/60_CVE-2010-3837.dpatch
  - debian/patches/60_CVE-2010-3838.dpatch
  - debian/patches/60_CVE-2010-3839.dpatch
  - debian/patches/60_CVE-2010-3840.dpatch
  - debian/patches/61_disable_longfilename_test.dpatch
  - debian/patches/62_alter_table_fix.dpatch
  - debian/patches/63_cherrypick-upstream-49479.dpatch
  - debian/patches/10_readline_build_fix.dpatch
* debian/mysql-client-5.1.docs: removed EXCEPTIONS-CLIENT file
* debian/mysql-server-5.1.docs,debian/libmysqlclient16.docs,
  debian/libmysqlclient-dev.docs: removed, no longer necessary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd-line-utils/libedit/el.c
1
 
/*      $NetBSD: el.c,v 1.47 2009/01/18 12:17:24 lukem Exp $    */
 
1
/*      $NetBSD: el.c,v 1.68 2011/07/29 15:16:33 christos Exp $ */
2
2
 
3
3
/*-
4
4
 * Copyright (c) 1992, 1993
48
48
#include <string.h>
49
49
#include <stdlib.h>
50
50
#include <stdarg.h>
 
51
#include <ctype.h>
 
52
#include <locale.h>
 
53
#include <langinfo.h>
51
54
#include "el.h"
52
55
 
53
56
/* el_init():
56
59
public EditLine *
57
60
el_init(const char *prog, FILE *fin, FILE *fout, FILE *ferr)
58
61
{
59
 
 
60
 
        EditLine *el = (EditLine *) el_malloc(sizeof(EditLine));
 
62
        EditLine *el = el_malloc(sizeof(*el));
61
63
 
62
64
        if (el == NULL)
63
 
                return (NULL);
 
65
                return NULL;
64
66
 
65
67
        memset(el, 0, sizeof(EditLine));
66
68
 
69
71
        el->el_errfile = ferr;
70
72
 
71
73
        el->el_infd = fileno(fin);
 
74
        el->el_outfd = fileno(fout);
 
75
        el->el_errfd = fileno(ferr);
72
76
 
73
 
        if ((el->el_prog = el_strdup(prog)) == NULL) {
 
77
        el->el_prog = Strdup(ct_decode_string(prog, &el->el_scratch));
 
78
        if (el->el_prog == NULL) {
74
79
                el_free(el);
75
80
                return NULL;
76
81
        }
79
84
         * Initialize all the modules. Order is important!!!
80
85
         */
81
86
        el->el_flags = 0;
 
87
#ifdef WIDECHAR
 
88
        setlocale(LC_CTYPE, NULL);
 
89
        if (MB_CUR_MAX > 1)
 
90
                el->el_flags |= CHARSET_IS_MULTIBYTE;
 
91
#endif
82
92
 
83
 
        if (term_init(el) == -1) {
 
93
        if (terminal_init(el) == -1) {
84
94
                el_free(el->el_prog);
85
95
                el_free(el);
86
96
                return NULL;
87
97
        }
88
 
        (void) key_init(el);
 
98
        (void) keymacro_init(el);
89
99
        (void) map_init(el);
90
100
        if (tty_init(el) == -1)
91
101
                el->el_flags |= NO_TTY;
96
106
        (void) sig_init(el);
97
107
        (void) read_init(el);
98
108
 
99
 
        return (el);
 
109
        return el;
100
110
}
101
111
 
102
112
 
112
122
 
113
123
        el_reset(el);
114
124
 
115
 
        term_end(el);
116
 
        key_end(el);
 
125
        terminal_end(el);
 
126
        keymacro_end(el);
117
127
        map_end(el);
118
128
        tty_end(el);
119
129
        ch_end(el);
122
132
        prompt_end(el);
123
133
        sig_end(el);
124
134
 
125
 
        el_free((ptr_t) el->el_prog);
126
 
        el_free((ptr_t) el);
 
135
        el_free(el->el_prog);
 
136
#ifdef WIDECHAR
 
137
        el_free(el->el_scratch.cbuff);
 
138
        el_free(el->el_scratch.wbuff);
 
139
        el_free(el->el_lgcyconv.cbuff);
 
140
        el_free(el->el_lgcyconv.wbuff);
 
141
#endif
 
142
        el_free(el);
127
143
}
128
144
 
129
145
 
143
159
 *      set the editline parameters
144
160
 */
145
161
public int
146
 
el_set(EditLine *el, int op, ...)
 
162
FUN(el,set)(EditLine *el, int op, ...)
147
163
{
148
164
        va_list ap;
149
165
        int rv = 0;
150
166
 
151
167
        if (el == NULL)
152
 
                return (-1);
 
168
                return -1;
153
169
        va_start(ap, op);
154
170
 
155
171
        switch (op) {
156
172
        case EL_PROMPT:
157
 
        case EL_RPROMPT:
158
 
                rv = prompt_set(el, va_arg(ap, el_pfunc_t), op);
159
 
                break;
 
173
        case EL_RPROMPT: {
 
174
                el_pfunc_t p = va_arg(ap, el_pfunc_t);
 
175
 
 
176
                rv = prompt_set(el, p, 0, op, 1);
 
177
                break;
 
178
        }
 
179
 
 
180
        case EL_RESIZE: {
 
181
                el_zfunc_t p = va_arg(ap, el_zfunc_t);
 
182
                void *arg = va_arg(ap, void *);
 
183
                rv = ch_resizefun(el, p, arg);
 
184
                break;
 
185
        }
 
186
 
 
187
        case EL_PROMPT_ESC:
 
188
        case EL_RPROMPT_ESC: {
 
189
                el_pfunc_t p = va_arg(ap, el_pfunc_t);
 
190
                int c = va_arg(ap, int);
 
191
 
 
192
                rv = prompt_set(el, p, c, op, 1);
 
193
                break;
 
194
        }
160
195
 
161
196
        case EL_TERMINAL:
162
 
                rv = term_set(el, va_arg(ap, char *));
 
197
                rv = terminal_set(el, va_arg(ap, char *));
163
198
                break;
164
199
 
165
200
        case EL_EDITOR:
166
 
                rv = map_set_editor(el, va_arg(ap, char *));
 
201
                rv = map_set_editor(el, va_arg(ap, Char *));
167
202
                break;
168
203
 
169
204
        case EL_SIGNAL:
176
211
        case EL_BIND:
177
212
        case EL_TELLTC:
178
213
        case EL_SETTC:
179
 
        case EL_GETTC:
180
214
        case EL_ECHOTC:
181
215
        case EL_SETTY:
182
216
        {
183
 
                const char *argv[20];
 
217
                const Char *argv[20];
184
218
                int i;
185
219
 
186
220
                for (i = 1; i < 20; i++)
187
 
                        if ((argv[i] = va_arg(ap, char *)) == NULL)
 
221
                        if ((argv[i] = va_arg(ap, Char *)) == NULL)
188
222
                                break;
189
223
 
190
224
                switch (op) {
191
225
                case EL_BIND:
192
 
                        argv[0] = "bind";
 
226
                        argv[0] = STR("bind");
193
227
                        rv = map_bind(el, i, argv);
194
228
                        break;
195
229
 
196
230
                case EL_TELLTC:
197
 
                        argv[0] = "telltc";
198
 
                        rv = term_telltc(el, i, argv);
 
231
                        argv[0] = STR("telltc");
 
232
                        rv = terminal_telltc(el, i, argv);
199
233
                        break;
200
234
 
201
235
                case EL_SETTC:
202
 
                        argv[0] = "settc";
203
 
                        rv = term_settc(el, i, argv);
 
236
                        argv[0] = STR("settc");
 
237
                        rv = terminal_settc(el, i, argv);
204
238
                        break;
205
239
 
206
240
                case EL_ECHOTC:
207
 
                        argv[0] = "echotc";
208
 
                        rv = term_echotc(el, i, argv);
 
241
                        argv[0] = STR("echotc");
 
242
                        rv = terminal_echotc(el, i, argv);
209
243
                        break;
210
244
 
211
245
                case EL_SETTY:
212
 
                        argv[0] = "setty";
 
246
                        argv[0] = STR("setty");
213
247
                        rv = tty_stty(el, i, argv);
214
248
                        break;
215
249
 
223
257
 
224
258
        case EL_ADDFN:
225
259
        {
226
 
                char *name = va_arg(ap, char *);
227
 
                char *help = va_arg(ap, char *);
 
260
                Char *name = va_arg(ap, Char *);
 
261
                Char *help = va_arg(ap, Char *);
228
262
                el_func_t func = va_arg(ap, el_func_t);
229
263
 
230
264
                rv = map_addfunc(el, name, help, func);
234
268
        case EL_HIST:
235
269
        {
236
270
                hist_fun_t func = va_arg(ap, hist_fun_t);
237
 
                ptr_t ptr = va_arg(ap, char *);
 
271
                void *ptr = va_arg(ap, void *);
238
272
 
239
273
                rv = hist_set(el, func, ptr);
 
274
                if (!(el->el_flags & CHARSET_IS_MULTIBYTE))
 
275
                        el->el_flags &= ~NARROW_HISTORY;
240
276
                break;
241
277
        }
242
278
 
252
288
        {
253
289
                el_rfunc_t rc = va_arg(ap, el_rfunc_t);
254
290
                rv = el_read_setfn(el, rc);
 
291
                el->el_flags &= ~NARROW_READ;
255
292
                break;
256
293
        }
257
294
 
296
333
                        break;
297
334
                case 1:
298
335
                        el->el_outfile = fp;
 
336
                        el->el_outfd = fileno(fp);
299
337
                        break;
300
338
                case 2:
301
339
                        el->el_errfile = fp;
 
340
                        el->el_errfd = fileno(fp);
302
341
                        break;
303
342
                default:
304
343
                        rv = -1;
310
349
        case EL_REFRESH:
311
350
                re_clear_display(el);
312
351
                re_refresh(el);
313
 
                term__flush(el);
 
352
                terminal__flush(el);
314
353
                break;
315
354
 
316
355
        default:
319
358
        }
320
359
 
321
360
        va_end(ap);
322
 
        return (rv);
 
361
        return rv;
323
362
}
324
363
 
325
364
 
327
366
 *      retrieve the editline parameters
328
367
 */
329
368
public int
330
 
el_get(EditLine *el, int op, ...)
 
369
FUN(el,get)(EditLine *el, int op, ...)
331
370
{
332
371
        va_list ap;
333
372
        int rv;
339
378
 
340
379
        switch (op) {
341
380
        case EL_PROMPT:
342
 
        case EL_RPROMPT:
343
 
                rv = prompt_get(el, va_arg(ap, el_pfunc_t *), op);
344
 
                break;
 
381
        case EL_RPROMPT: {
 
382
                el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
 
383
                rv = prompt_get(el, p, 0, op);
 
384
                break;
 
385
        }
 
386
        case EL_PROMPT_ESC:
 
387
        case EL_RPROMPT_ESC: {
 
388
                el_pfunc_t *p = va_arg(ap, el_pfunc_t *);
 
389
                Char *c = va_arg(ap, Char *);
 
390
 
 
391
                rv = prompt_get(el, p, c, op);
 
392
                break;
 
393
        }
345
394
 
346
395
        case EL_EDITOR:
347
 
                rv = map_get_editor(el, va_arg(ap, const char **));
 
396
                rv = map_get_editor(el, va_arg(ap, const Char **));
348
397
                break;
349
398
 
350
399
        case EL_SIGNAL:
358
407
                break;
359
408
 
360
409
        case EL_TERMINAL:
361
 
                term_get(el, va_arg(ap, const char **));
 
410
                terminal_get(el, va_arg(ap, const char **));
362
411
                rv = 0;
363
412
                break;
364
413
 
375
424
                switch (op) {
376
425
                case EL_GETTC:
377
426
                        argv[0] = name;
378
 
                        rv = term_gettc(el, i, argv);
 
427
                        rv = terminal_gettc(el, i, argv);
379
428
                        break;
380
429
 
381
430
                default:
386
435
                break;
387
436
        }
388
437
 
389
 
#if 0 /* XXX */
390
 
        case EL_ADDFN:
391
 
        {
392
 
                char *name = va_arg(ap, char *);
393
 
                char *help = va_arg(ap, char *);
394
 
                el_func_t func = va_arg(ap, el_func_t);
395
 
 
396
 
                rv = map_addfunc(el, name, help, func);
397
 
                break;
398
 
        }
399
 
 
400
 
        case EL_HIST:
401
 
                {
402
 
                        hist_fun_t func = va_arg(ap, hist_fun_t);
403
 
                        ptr_t ptr = va_arg(ap, char *);
404
 
                        rv = hist_set(el, func, ptr);
405
 
                }
406
 
                break;
407
 
#endif /* XXX */
408
 
 
409
438
        case EL_GETCFN:
410
439
                *va_arg(ap, el_rfunc_t *) = el_read_getfn(el);
411
440
                rv = 0;
451
480
        }
452
481
        va_end(ap);
453
482
 
454
 
        return (rv);
 
483
        return rv;
455
484
}
456
485
 
457
486
 
458
487
/* el_line():
459
488
 *      Return editing info
460
489
 */
461
 
public const LineInfo *
462
 
el_line(EditLine *el)
 
490
public const TYPE(LineInfo) *
 
491
FUN(el,line)(EditLine *el)
463
492
{
464
493
 
465
 
        return (const LineInfo *) (void *) &el->el_line;
 
494
        return (const TYPE(LineInfo) *)(void *)&el->el_line;
466
495
}
467
496
 
468
497
 
475
504
        FILE *fp;
476
505
        size_t len;
477
506
        char *ptr;
 
507
        char *path = NULL;
 
508
        const Char *dptr;
 
509
        int error = 0;
478
510
 
479
511
        fp = NULL;
480
512
        if (fname == NULL) {
481
 
#ifdef HAVE_ISSETUGID
 
513
/* XXXMYSQL: Bug#49967 */
 
514
#if defined(HAVE_GETUID) && defined(HAVE_GETEUID) && \
 
515
    defined(HAVE_GETGID) && defined(HAVE_GETEGID)
 
516
#define HAVE_IDENTITY_FUNCS 1
 
517
#endif
 
518
 
 
519
#if (defined(HAVE_ISSETUGID) || defined(HAVE_IDENTITY_FUNCS))
482
520
                static const char elpath[] = "/.editrc";
 
521
                size_t plen = sizeof(elpath);
483
522
/* XXXMYSQL: Portability fix (for which platforms?) */
484
 
#ifdef MAXPATHLEN
485
 
                char path[MAXPATHLEN];
486
 
#else
487
 
                char path[4096];
488
 
#endif
489
 
 
 
523
#ifdef HAVE_ISSETUGID
490
524
                if (issetugid())
491
 
                        return (-1);
 
525
                        return -1;
 
526
#elif defined(HAVE_IDENTITY_FUNCS)
 
527
                if (getuid() != geteuid() || getgid() != getegid())
 
528
                  return (-1);
 
529
#endif
492
530
                if ((ptr = getenv("HOME")) == NULL)
493
 
                        return (-1);
494
 
                if (strlcpy(path, ptr, sizeof(path)) >= sizeof(path))
495
 
                        return (-1);
496
 
                if (strlcat(path, elpath, sizeof(path)) >= sizeof(path))
497
 
                        return (-1);
 
531
                        return -1;
 
532
                plen += strlen(ptr);
 
533
                if ((path = el_malloc(plen * sizeof(*path))) == NULL)
 
534
                        return -1;
 
535
                (void)snprintf(path, plen, "%s%s", ptr, elpath);
498
536
                fname = path;
499
537
#else
500
538
                /*
501
 
                 * If issetugid() is missing, always return an error, in order
502
 
                 * to keep from inadvertently opening up the user to a security
503
 
                 * hole.
 
539
                 * If issetugid() or the above mentioned get[e][u|g]id()
 
540
                 * functions are missing, always return an error, in order
 
541
                 * to keep from inadvertently opening up the user to a
 
542
                 * security hole.
504
543
                 */
505
 
                return (-1);
 
544
                return -1;
506
545
#endif
507
546
        }
508
547
        if (fp == NULL)
509
548
                fp = fopen(fname, "r");
510
 
        if (fp == NULL)
511
 
                return (-1);
 
549
        if (fp == NULL) {
 
550
                el_free(path);
 
551
                return -1;
 
552
        }
512
553
 
513
554
        while ((ptr = fgetln(fp, &len)) != NULL) {
514
 
                if (len > 0 && ptr[len - 1] == '\n')
 
555
                if (*ptr == '\n')
 
556
                        continue;       /* Empty line. */
 
557
                dptr = ct_decode_string(ptr, &el->el_scratch);
 
558
                if (!dptr)
 
559
                        continue;
 
560
                if (len > 0 && dptr[len - 1] == '\n')
515
561
                        --len;
516
 
                ptr[len] = '\0';
517
 
                if (parse_line(el, ptr) == -1) {
518
 
                        (void) fclose(fp);
519
 
                        return (-1);
520
 
                }
 
562
 
 
563
                /* loop until first non-space char or EOL */
 
564
                while (*dptr != '\0' && Isspace(*dptr))
 
565
                        dptr++;
 
566
                if (*dptr == '#')
 
567
                        continue;   /* ignore, this is a comment line */
 
568
                if ((error = parse_line(el, dptr)) == -1)
 
569
                        break;
521
570
        }
522
571
 
 
572
        el_free(path);
523
573
        (void) fclose(fp);
524
 
        return (0);
 
574
        return error;
525
575
}
526
576
 
527
577
 
539
589
        (void) sigprocmask(SIG_BLOCK, &nset, &oset);
540
590
 
541
591
        /* get the correct window size */
542
 
        if (term_get_size(el, &lins, &cols))
543
 
                term_change_size(el, lins, cols);
 
592
        if (terminal_get_size(el, &lins, &cols))
 
593
                terminal_change_size(el, lins, cols);
544
594
 
545
595
        (void) sigprocmask(SIG_SETMASK, &oset, NULL);
546
596
}
553
603
el_beep(EditLine *el)
554
604
{
555
605
 
556
 
        term_beep(el);
 
606
        terminal_beep(el);
557
607
}
558
608
 
559
609
 
562
612
 */
563
613
protected int
564
614
/*ARGSUSED*/
565
 
el_editmode(EditLine *el, int argc, const char **argv)
 
615
el_editmode(EditLine *el, int argc, const Char **argv)
566
616
{
567
 
        const char *how;
 
617
        const Char *how;
568
618
 
569
619
        if (argv == NULL || argc != 2 || argv[1] == NULL)
570
 
                return (-1);
 
620
                return -1;
571
621
 
572
622
        how = argv[1];
573
 
        if (strcmp(how, "on") == 0) {
 
623
        if (Strcmp(how, STR("on")) == 0) {
574
624
                el->el_flags &= ~EDIT_DISABLED;
575
625
                tty_rawmode(el);
576
 
        } else if (strcmp(how, "off") == 0) {
 
626
        } else if (Strcmp(how, STR("off")) == 0) {
577
627
                tty_cookedmode(el);
578
628
                el->el_flags |= EDIT_DISABLED;
579
629
        }
580
630
        else {
581
 
                (void) fprintf(el->el_errfile, "edit: Bad value `%s'.\n", how);
582
 
                return (-1);
 
631
                (void) fprintf(el->el_errfile, "edit: Bad value `" FSTR "'.\n",
 
632
                    how);
 
633
                return -1;
583
634
        }
584
 
        return (0);
 
635
        return 0;
585
636
}