← Back to branch summary

~mathiaz/ubuntu/lucid/mysql-dfsg-5.1/zap-bug-552053

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Mathias Gug
  • Date: 2009-06-25 12:55:45 UTC
  • mfrom: (1.1.2 upstream) (0.1.3 experimental)
  • Revision ID: james.westby@ubuntu.com-20090625125545-m8ogs96zzsri74xe
Tags: 5.1.34-1ubuntu1
https://launchpad.net/bugs/319843
https://launchpad.net/bugs/259477
https://launchpad.net/bugs/310211
https://launchpad.net/bugs/201799
https://launchpad.net/bugs/316974
http://bugs.debian.org/314785
http://bugs.debian.org/324834
http://bugs.debian.org/435165
http://bugs.debian.org/444216
https://launchpad.net/bugs/344816
https://launchpad.net/bugs/323755
* Merge from debian experimental (and 5.0 from main), remaining changes:
  - debian/mysql-server-5.1.config:
    + ask for MySQL root password at priority high instead of medium so
      that the password prompt is seen on a default install. (LP: #319843)
    + don't ask for root password when upgrading from a 5.0 install.
  - debian/control:
    + Make libmysqlclient16-dev a transitional package depending on
      libmysqlclient-dev.
    + Make libmysqlclient-dev conflict with libmysqlclient15-dev.
    + Don't build mysql-server, mysql-client, mysql-common and
      libmysqlclient15-dev binary packages since they're still provided
      by mysql-dfsg-5.0.
    + Make mysql-{client,server}-5.1 packages conflict and
      replace mysql-{client,server}-5.0, but not provide
      mysql-{client,server}.
    + Depend on a specific version of mysql-common rather than the src
      version of mysql-dfsg-5.1 since mysql-common is currently part of
      mysql-dfsg-5.0.
    + Lower mailx from a Recommends to a Suggests to avoid pulling in
      a full MTA on all installs of mysql-server. (LP: #259477)
  - debian/rules:
    + added -fno-strict-aliasing to CFLAGS to get around mysql testsuite
      build failures.
    + install mysql-test and sql-bench to /usr/share/mysql/ rather than
      /usr/.
  - debian/additions/debian-start.inc.sh: support ANSI mode (LP: #310211)
  - Add AppArmor profile:
    - debian/apparmor-profile: apparmor profile.
    - debian/rules, debian/mysql-server-5.0.files: install apparmor profile.
    - debian/mysql-server-5.0.dirs: add etc/apparmor.d/force-complain
    - debian/mysql-server-5.0.postrm: remove symlink in force-complain/ on
      purge.
    - debian/mysql-server-5.1.README.Debian: add apparmor documentation.
    - debian/additions/my.cnf: Add warning about apparmor. (LP: #201799)
    - debian/mysql-server-5.1.postinst: reload apparmor profiles.
  - debian/additions/my.cnf: remove language option. Error message files are
    located in a different directory in MySQL 5.0. Setting the language
    option to use /usr/share/mysql/english breaks 5.0. Both 5.0 and 5.1
    use a default value that works. (LP: #316974)
  - debian/mysql-server-5.1.mysql.init:
    + Clearly indicate that we do not support running multiple instances
      of mysqld by duplicating the init script.
      (closes: #314785, #324834, #435165, #444216)
    + Properly parameterize all existing references to the mysql config
      file (/etc/mysql/my.cnf).
  - debian/mysql-server-5.0.postinst: Clear out the second password
    when setting up mysql. (LP: #344816)
  - mysql-server-core-5.1 package for files needed by Akonadi:
    + debian/control: create mysql-server-core-5.1 package.
    + debian/mysql-server-core-5.1.files, debian/mysql-server-5.1.files:
      move core mysqld files to mysql-server-core-5.1 package.
  - Don't package sql-bench and mysql-test file.
* Dropped changes:
  - debian/patches/92_ssl_test_cert.dpatch: certificate expiration in
    test suite (LP: #323755). Included upstream.
* Dropped from 5.0:
  - apparmor profile:
    - debian/control: Recommends apparmor >= 2.1+1075-0ubuntu6. All version
      of apparmor-profile (>hardy) are higher than this version.
    - debian/mysql-server-5.0.preinst: create symlink for force-complain/
      on pre-feisty upgrades, upgrades where apparmor-profiles profile is
      unchanged (ie non-enforcing) and upgrades where the profile
      doesn't exist. Support for pre-hardy upgrades is no longer needed.
* debian/mysql-server-5.1.postinst: fix debian-sys-maint user creation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd-line-utils/libedit/el.c
1
 
/*      $NetBSD: el.c,v 1.39 2004/07/08 00:51:36 christos Exp $ */
 
1
/*      $NetBSD: el.c,v 1.47 2009/01/18 12:17:24 lukem Exp $    */
2
2
 
3
3
/*-
4
4
 * Copyright (c) 1992, 1993
32
32
 * SUCH DAMAGE.
33
33
 */
34
34
 
35
 
#include <config.h>
 
35
#include "config.h"
 
36
#if !defined(lint) && !defined(SCCSID)
 
37
#if 0
 
38
static char sccsid[] = "@(#)el.c        8.2 (Berkeley) 1/3/94";
 
39
#else
 
40
#endif
 
41
#endif /* not lint && not SCCSID */
36
42
 
37
43
/*
38
44
 * el.c: EditLine interface functions
58
64
 
59
65
        memset(el, 0, sizeof(EditLine));
60
66
 
61
 
        el->el_infd = fileno(fin);
 
67
        el->el_infile = fin;
62
68
        el->el_outfile = fout;
63
69
        el->el_errfile = ferr;
 
70
 
 
71
        el->el_infd = fileno(fin);
 
72
 
64
73
        if ((el->el_prog = el_strdup(prog)) == NULL) {
65
74
                el_free(el);
66
75
                return NULL;
126
135
{
127
136
 
128
137
        tty_cookedmode(el);
129
 
        ch_reset(el);           /* XXX: Do we want that? */
 
138
        ch_reset(el, 0);                /* XXX: Do we want that? */
130
139
}
131
140
 
132
141
 
136
145
public int
137
146
el_set(EditLine *el, int op, ...)
138
147
{
139
 
        va_list va;
 
148
        va_list ap;
140
149
        int rv = 0;
141
150
 
142
151
        if (el == NULL)
143
152
                return (-1);
144
 
        va_start(va, op);
 
153
        va_start(ap, op);
145
154
 
146
155
        switch (op) {
147
156
        case EL_PROMPT:
148
157
        case EL_RPROMPT:
149
 
                rv = prompt_set(el, va_arg(va, el_pfunc_t), op);
 
158
                rv = prompt_set(el, va_arg(ap, el_pfunc_t), op);
150
159
                break;
151
160
 
152
161
        case EL_TERMINAL:
153
 
                rv = term_set(el, va_arg(va, char *));
 
162
                rv = term_set(el, va_arg(ap, char *));
154
163
                break;
155
164
 
156
165
        case EL_EDITOR:
157
 
                rv = map_set_editor(el, va_arg(va, char *));
 
166
                rv = map_set_editor(el, va_arg(ap, char *));
158
167
                break;
159
168
 
160
169
        case EL_SIGNAL:
161
 
                if (va_arg(va, int))
 
170
                if (va_arg(ap, int))
162
171
                        el->el_flags |= HANDLE_SIGNALS;
163
172
                else
164
173
                        el->el_flags &= ~HANDLE_SIGNALS;
167
176
        case EL_BIND:
168
177
        case EL_TELLTC:
169
178
        case EL_SETTC:
 
179
        case EL_GETTC:
170
180
        case EL_ECHOTC:
171
181
        case EL_SETTY:
172
182
        {
174
184
                int i;
175
185
 
176
186
                for (i = 1; i < 20; i++)
177
 
                        if ((argv[i] = va_arg(va, char *)) == NULL)
 
187
                        if ((argv[i] = va_arg(ap, char *)) == NULL)
178
188
                                break;
179
189
 
180
190
                switch (op) {
213
223
 
214
224
        case EL_ADDFN:
215
225
        {
216
 
                char *name = va_arg(va, char *);
217
 
                char *help = va_arg(va, char *);
218
 
                el_func_t func = va_arg(va, el_func_t);
 
226
                char *name = va_arg(ap, char *);
 
227
                char *help = va_arg(ap, char *);
 
228
                el_func_t func = va_arg(ap, el_func_t);
219
229
 
220
230
                rv = map_addfunc(el, name, help, func);
221
231
                break;
223
233
 
224
234
        case EL_HIST:
225
235
        {
226
 
                hist_fun_t func = va_arg(va, hist_fun_t);
227
 
                ptr_t ptr = va_arg(va, char *);
 
236
                hist_fun_t func = va_arg(ap, hist_fun_t);
 
237
                ptr_t ptr = va_arg(ap, char *);
228
238
 
229
239
                rv = hist_set(el, func, ptr);
230
240
                break;
231
241
        }
232
242
 
233
243
        case EL_EDITMODE:
234
 
                if (va_arg(va, int))
 
244
                if (va_arg(ap, int))
235
245
                        el->el_flags &= ~EDIT_DISABLED;
236
246
                else
237
247
                        el->el_flags |= EDIT_DISABLED;
240
250
 
241
251
        case EL_GETCFN:
242
252
        {
243
 
                el_rfunc_t rc = va_arg(va, el_rfunc_t);
 
253
                el_rfunc_t rc = va_arg(ap, el_rfunc_t);
244
254
                rv = el_read_setfn(el, rc);
245
255
                break;
246
256
        }
247
257
 
248
258
        case EL_CLIENTDATA:
249
 
                el->el_data = va_arg(va, void *);
 
259
                el->el_data = va_arg(ap, void *);
250
260
                break;
251
261
 
252
262
        case EL_UNBUFFERED:
253
 
                rv = va_arg(va, int);
 
263
                rv = va_arg(ap, int);
254
264
                if (rv && !(el->el_flags & UNBUFFERED)) {
255
265
                        el->el_flags |= UNBUFFERED;
256
266
                        read_prepare(el);
262
272
                break;
263
273
 
264
274
        case EL_PREP_TERM:
265
 
                rv = va_arg(va, int);
 
275
                rv = va_arg(ap, int);
266
276
                if (rv)
267
277
                        (void) tty_rawmode(el);
268
278
                else
270
280
                rv = 0;
271
281
                break;
272
282
 
 
283
        case EL_SETFP:
 
284
        {
 
285
                FILE *fp;
 
286
                int what;
 
287
 
 
288
                what = va_arg(ap, int);
 
289
                fp = va_arg(ap, FILE *);
 
290
 
 
291
                rv = 0;
 
292
                switch (what) {
 
293
                case 0:
 
294
                        el->el_infile = fp;
 
295
                        el->el_infd = fileno(fp);
 
296
                        break;
 
297
                case 1:
 
298
                        el->el_outfile = fp;
 
299
                        break;
 
300
                case 2:
 
301
                        el->el_errfile = fp;
 
302
                        break;
 
303
                default:
 
304
                        rv = -1;
 
305
                        break;
 
306
                }
 
307
                break;
 
308
        }
 
309
 
 
310
        case EL_REFRESH:
 
311
                re_clear_display(el);
 
312
                re_refresh(el);
 
313
                term__flush(el);
 
314
                break;
 
315
 
273
316
        default:
274
317
                rv = -1;
275
318
                break;
276
319
        }
277
320
 
278
 
        va_end(va);
 
321
        va_end(ap);
279
322
        return (rv);
280
323
}
281
324
 
284
327
 *      retrieve the editline parameters
285
328
 */
286
329
public int
287
 
el_get(EditLine *el, int op, void *ret)
 
330
el_get(EditLine *el, int op, ...)
288
331
{
 
332
        va_list ap;
289
333
        int rv;
290
334
 
291
 
        if (el == NULL || ret == NULL)
292
 
                return (-1);
 
335
        if (el == NULL)
 
336
                return -1;
 
337
 
 
338
        va_start(ap, op);
 
339
 
293
340
        switch (op) {
294
341
        case EL_PROMPT:
295
342
        case EL_RPROMPT:
296
 
                rv = prompt_get(el, (void *) &ret, op);
 
343
                rv = prompt_get(el, va_arg(ap, el_pfunc_t *), op);
297
344
                break;
298
345
 
299
346
        case EL_EDITOR:
300
 
                rv = map_get_editor(el, (void *) &ret);
 
347
                rv = map_get_editor(el, va_arg(ap, const char **));
301
348
                break;
302
349
 
303
350
        case EL_SIGNAL:
304
 
                *((int *) ret) = (el->el_flags & HANDLE_SIGNALS);
 
351
                *va_arg(ap, int *) = (el->el_flags & HANDLE_SIGNALS);
305
352
                rv = 0;
306
353
                break;
307
354
 
308
355
        case EL_EDITMODE:
309
 
                *((int *) ret) = (!(el->el_flags & EDIT_DISABLED));
 
356
                *va_arg(ap, int *) = !(el->el_flags & EDIT_DISABLED);
310
357
                rv = 0;
311
358
                break;
312
359
 
313
360
        case EL_TERMINAL:
314
 
                term_get(el, (const char **)ret);
 
361
                term_get(el, va_arg(ap, const char **));
315
362
                rv = 0;
316
363
                break;
317
364
 
318
 
#if 0                           /* XXX */
319
 
        case EL_BIND:
320
 
        case EL_TELLTC:
321
 
        case EL_SETTC:
322
 
        case EL_ECHOTC:
323
 
        case EL_SETTY:
 
365
        case EL_GETTC:
324
366
        {
325
 
                const char *argv[20];
 
367
                static char name[] = "gettc";
 
368
                char *argv[20];
326
369
                int i;
327
370
 
328
 
                for (i = 1; i < sizeof(argv) / sizeof(argv[0]); i++)
329
 
                        if ((argv[i] = va_arg(va, char *)) == NULL)
 
371
                for (i = 1; i < (int)(sizeof(argv) / sizeof(argv[0])); i++)
 
372
                        if ((argv[i] = va_arg(ap, char *)) == NULL)
330
373
                                break;
331
374
 
332
375
                switch (op) {
333
 
                case EL_BIND:
334
 
                        argv[0] = "bind";
335
 
                        rv = map_bind(el, i, argv);
336
 
                        break;
337
 
 
338
 
                case EL_TELLTC:
339
 
                        argv[0] = "telltc";
340
 
                        rv = term_telltc(el, i, argv);
341
 
                        break;
342
 
 
343
 
                case EL_SETTC:
344
 
                        argv[0] = "settc";
345
 
                        rv = term_settc(el, i, argv);
346
 
                        break;
347
 
 
348
 
                case EL_ECHOTC:
349
 
                        argv[0] = "echotc";
350
 
                        rv = term_echotc(el, i, argv);
351
 
                        break;
352
 
 
353
 
                case EL_SETTY:
354
 
                        argv[0] = "setty";
355
 
                        rv = tty_stty(el, i, argv);
 
376
                case EL_GETTC:
 
377
                        argv[0] = name;
 
378
                        rv = term_gettc(el, i, argv);
356
379
                        break;
357
380
 
358
381
                default:
359
382
                        rv = -1;
360
 
                        EL_ABORT((el->errfile, "Bad op %d\n", op));
 
383
                        EL_ABORT((el->el_errfile, "Bad op %d\n", op));
361
384
                        break;
362
385
                }
363
386
                break;
364
387
        }
365
388
 
 
389
#if 0 /* XXX */
366
390
        case EL_ADDFN:
367
391
        {
368
 
                char *name = va_arg(va, char *);
369
 
                char *help = va_arg(va, char *);
370
 
                el_func_t func = va_arg(va, el_func_t);
 
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);
371
395
 
372
396
                rv = map_addfunc(el, name, help, func);
373
397
                break;
375
399
 
376
400
        case EL_HIST:
377
401
                {
378
 
                        hist_fun_t func = va_arg(va, hist_fun_t);
379
 
                        ptr_t ptr = va_arg(va, char *);
 
402
                        hist_fun_t func = va_arg(ap, hist_fun_t);
 
403
                        ptr_t ptr = va_arg(ap, char *);
380
404
                        rv = hist_set(el, func, ptr);
381
405
                }
382
406
                break;
383
407
#endif /* XXX */
384
408
 
385
409
        case EL_GETCFN:
386
 
                *((el_rfunc_t *)ret) = el_read_getfn(el);
 
410
                *va_arg(ap, el_rfunc_t *) = el_read_getfn(el);
387
411
                rv = 0;
388
412
                break;
389
413
 
390
414
        case EL_CLIENTDATA:
391
 
                *((void **)ret) = el->el_data;
 
415
                *va_arg(ap, void **) = el->el_data;
392
416
                rv = 0;
393
417
                break;
394
418
 
395
419
        case EL_UNBUFFERED:
396
 
                *((int *) ret) = (!(el->el_flags & UNBUFFERED));
397
 
                rv = 0;
398
 
                break;
399
 
 
 
420
                *va_arg(ap, int *) = (!(el->el_flags & UNBUFFERED));
 
421
                rv = 0;
 
422
                break;
 
423
 
 
424
        case EL_GETFP:
 
425
        {
 
426
                int what;
 
427
                FILE **fpp;
 
428
 
 
429
                what = va_arg(ap, int);
 
430
                fpp = va_arg(ap, FILE **);
 
431
                rv = 0;
 
432
                switch (what) {
 
433
                case 0:
 
434
                        *fpp = el->el_infile;
 
435
                        break;
 
436
                case 1:
 
437
                        *fpp = el->el_outfile;
 
438
                        break;
 
439
                case 2:
 
440
                        *fpp = el->el_errfile;
 
441
                        break;
 
442
                default:
 
443
                        rv = -1;
 
444
                        break;
 
445
                }
 
446
                break;
 
447
        }
400
448
        default:
401
449
                rv = -1;
 
450
                break;
402
451
        }
 
452
        va_end(ap);
403
453
 
404
454
        return (rv);
405
455
}
428
478
 
429
479
        fp = NULL;
430
480
        if (fname == NULL) {
 
481
#ifdef HAVE_ISSETUGID
431
482
                static const char elpath[] = "/.editrc";
 
483
/* XXXMYSQL: Portability fix (for which platforms?) */
432
484
#ifdef MAXPATHLEN
433
485
                char path[MAXPATHLEN];
434
486
#else
435
487
                char path[4096];
436
488
#endif
437
489
 
438
 
#ifdef HAVE_ISSETUGID
439
490
                if (issetugid())
440
491
                        return (-1);
441
 
#endif
442
492
                if ((ptr = getenv("HOME")) == NULL)
443
493
                        return (-1);
444
494
                if (strlcpy(path, ptr, sizeof(path)) >= sizeof(path))
446
496
                if (strlcat(path, elpath, sizeof(path)) >= sizeof(path))
447
497
                        return (-1);
448
498
                fname = path;
 
499
#else
 
500
                /*
 
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.
 
504
                 */
 
505
                return (-1);
 
506
#endif
449
507
        }
450
508
        if (fp == NULL)
451
509
                fp = fopen(fname, "r");