← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.5/precise-201203300109

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Clint Byrum
  • Date: 2012-02-14 23:59:22 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20120214235922-cux5uek1e5l0hje9
Tags: 5.5.20-0ubuntu1
https://launchpad.net/bugs/688541
https://launchpad.net/bugs/907465
https://launchpad.net/bugs/917542
https://launchpad.net/bugs/912487
http://bugs.debian.org/659566
* New upstream release.
* d/mysql-server-5.5.mysql.upstart: Fix stop on to make sure mysql is
  fully stopped before shutdown commences. (LP: #688541) Also simplify
  start on as it is redundant.
* d/control: Depend on upstart version which has apparmor profile load
  script to prevent failure on upgrade from lucid to precise.
  (LP: #907465)
* d/apparmor-profile: need to allow /run since that is the true path
  of /var/run files. (LP: #917542)
* d/control: mysql-server-5.5 has files in it that used to be owned
  by libmysqlclient-dev, so it must break/replace it. (LP: #912487)
* d/rules, d/control: 5.5.20 Fixes segfault on tests with gcc 4.6,
  change compiler back to system default.
* d/rules: Turn off embedded libedit/readline.(Closes: #659566)

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd-line-utils/libedit/sig.c
1
 
/*      $NetBSD: sig.c,v 1.12 2008/09/10 15:45:37 christos Exp $        */
 
1
/*      $NetBSD: sig.c,v 1.17 2011/07/28 20:50:55 christos Exp $        */
2
2
 
3
3
/*-
4
4
 * Copyright (c) 1992, 1993
57
57
        - 1
58
58
};
59
59
 
60
 
private void el_sig_handler(int);
 
60
private void sig_handler(int);
61
61
 
62
 
/* el_sig_handler():
 
62
/* sig_handler():
63
63
 *      This is the handler called for all signals
64
64
 *      XXX: we cannot pass any data so we just store the old editline
65
65
 *      state in a private variable
66
66
 */
67
67
private void
68
 
el_sig_handler(int signo)
 
68
sig_handler(int signo)
69
69
{
70
70
        int i;
71
71
        sigset_t nset, oset;
74
74
        (void) sigaddset(&nset, signo);
75
75
        (void) sigprocmask(SIG_BLOCK, &nset, &oset);
76
76
 
 
77
        sel->el_signal->sig_no = signo;
 
78
 
77
79
        switch (signo) {
78
80
        case SIGCONT:
79
81
                tty_rawmode(sel);
80
82
                if (ed_redisplay(sel, 0) == CC_REFRESH)
81
83
                        re_refresh(sel);
82
 
                term__flush(sel);
 
84
                terminal__flush(sel);
83
85
                break;
84
86
 
85
87
        case SIGWINCH:
95
97
                if (signo == sighdl[i])
96
98
                        break;
97
99
 
98
 
        (void) signal(signo, sel->el_signal[i]);
 
100
        (void) sigaction(signo, &sel->el_signal->sig_action[i], NULL);
 
101
        sel->el_signal->sig_action[i].sa_handler = SIG_ERR;
 
102
        sel->el_signal->sig_action[i].sa_flags = 0;
 
103
        sigemptyset(&sel->el_signal->sig_action[i].sa_mask);
99
104
        (void) sigprocmask(SIG_SETMASK, &oset, NULL);
100
105
        (void) kill(0, signo);
101
106
}
107
112
protected int
108
113
sig_init(EditLine *el)
109
114
{
110
 
        int i;
111
 
        sigset_t nset, oset;
112
 
 
113
 
        (void) sigemptyset(&nset);
114
 
#define _DO(a) (void) sigaddset(&nset, a);
115
 
        ALLSIGS
116
 
#undef  _DO
117
 
            (void) sigprocmask(SIG_BLOCK, &nset, &oset);
118
 
 
119
 
#define SIGSIZE (sizeof(sighdl) / sizeof(sighdl[0]) * sizeof(el_signalhandler_t))
120
 
 
121
 
        el->el_signal = (el_signalhandler_t *) el_malloc(SIGSIZE);
 
115
        size_t i;
 
116
        sigset_t *nset, oset;
 
117
 
 
118
        el->el_signal = el_malloc(sizeof(*el->el_signal));
122
119
        if (el->el_signal == NULL)
123
 
                return (-1);
124
 
        for (i = 0; sighdl[i] != -1; i++)
125
 
                el->el_signal[i] = SIG_ERR;
 
120
                return -1;
 
121
 
 
122
        nset = &el->el_signal->sig_set;
 
123
        (void) sigemptyset(nset);
 
124
#define _DO(a) (void) sigaddset(nset, a);
 
125
        ALLSIGS
 
126
#undef  _DO
 
127
        (void) sigprocmask(SIG_BLOCK, nset, &oset);
 
128
 
 
129
        for (i = 0; sighdl[i] != -1; i++) {
 
130
                el->el_signal->sig_action[i].sa_handler = SIG_ERR;
 
131
                el->el_signal->sig_action[i].sa_flags = 0;
 
132
                sigemptyset(&el->el_signal->sig_action[i].sa_mask);
 
133
        }
126
134
 
127
135
        (void) sigprocmask(SIG_SETMASK, &oset, NULL);
128
136
 
129
 
        return (0);
 
137
        return 0;
130
138
}
131
139
 
132
140
 
137
145
sig_end(EditLine *el)
138
146
{
139
147
 
140
 
        el_free((ptr_t) el->el_signal);
 
148
        el_free(el->el_signal);
141
149
        el->el_signal = NULL;
142
150
}
143
151
 
148
156
protected void
149
157
sig_set(EditLine *el)
150
158
{
151
 
        int i;
152
 
        sigset_t nset, oset;
153
 
 
154
 
        (void) sigemptyset(&nset);
155
 
#define _DO(a) (void) sigaddset(&nset, a);
156
 
        ALLSIGS
157
 
#undef  _DO
158
 
            (void) sigprocmask(SIG_BLOCK, &nset, &oset);
 
159
        size_t i;
 
160
        sigset_t oset;
 
161
        struct sigaction osa, nsa;
 
162
 
 
163
        nsa.sa_handler = sig_handler;
 
164
        nsa.sa_flags = 0;
 
165
        sigemptyset(&nsa.sa_mask);
 
166
 
 
167
        (void) sigprocmask(SIG_BLOCK, &el->el_signal->sig_set, &oset);
159
168
 
160
169
        for (i = 0; sighdl[i] != -1; i++) {
161
 
                el_signalhandler_t s;
162
170
                /* This could happen if we get interrupted */
163
 
                if ((s = signal(sighdl[i], el_sig_handler)) != el_sig_handler)
164
 
                        el->el_signal[i] = s;
 
171
                if (sigaction(sighdl[i], &nsa, &osa) != -1 &&
 
172
                    osa.sa_handler != sig_handler)
 
173
                        el->el_signal->sig_action[i] = osa;
165
174
        }
166
175
        sel = el;
167
176
        (void) sigprocmask(SIG_SETMASK, &oset, NULL);
174
183
protected void
175
184
sig_clr(EditLine *el)
176
185
{
177
 
        int i;
178
 
        sigset_t nset, oset;
 
186
        size_t i;
 
187
        sigset_t oset;
179
188
 
180
 
        (void) sigemptyset(&nset);
181
 
#define _DO(a) (void) sigaddset(&nset, a);
182
 
        ALLSIGS
183
 
#undef  _DO
184
 
            (void) sigprocmask(SIG_BLOCK, &nset, &oset);
 
189
        (void) sigprocmask(SIG_BLOCK, &el->el_signal->sig_set, &oset);
185
190
 
186
191
        for (i = 0; sighdl[i] != -1; i++)
187
 
                if (el->el_signal[i] != SIG_ERR)
188
 
                        (void) signal(sighdl[i], el->el_signal[i]);
 
192
                if (el->el_signal->sig_action[i].sa_handler != SIG_ERR)
 
193
                        (void)sigaction(sighdl[i],
 
194
                            &el->el_signal->sig_action[i], NULL);
189
195
 
190
196
        sel = NULL;             /* we are going to die if the handler is
191
197
                                 * called */
192
 
        (void) sigprocmask(SIG_SETMASK, &oset, NULL);
 
198
        (void)sigprocmask(SIG_SETMASK, &oset, NULL);
193
199
}