about summary refs log tree commit diff stats
path: root/worker
diff options
context:
space:
mode:
authorMatt Snider <matt.snider@protonmail.com>2019-10-27 13:54:22 +0000
committerDrew DeVault <sir@cmpwn.com>2019-11-01 11:02:01 -0400
commitcd39e8f90cde6adb3d127454f99184d84d74d40c (patch)
tree832b874872121219e00108429ffb891f659db3c8 /worker
parent310bec27024579e7ada35585b3190ab875540804 (diff)
downloadaerc-cd39e8f90cde6adb3d127454f99184d84d74d40c.tar.gz
notmuch: ignore comments and blank lines when processing query-map file
A segmentation fault occurs when using the notmuch backend and a `query-map`
file that contains blank lines or comments.
Diffstat (limited to 'worker')
-rw-r--r--worker/notmuch/worker.go4
1 files changed, 4 insertions, 0 deletions
diff --git a/worker/notmuch/worker.go b/worker/notmuch/worker.go
index 96adc29..be213bf 100644
--- a/worker/notmuch/worker.go
+++ b/worker/notmuch/worker.go
@@ -387,6 +387,10 @@ func (w *worker) loadQueryMap(acctConfig *config.AccountConfig) error {
 	scanner := bufio.NewScanner(f)
 	for scanner.Scan() {
 		line := scanner.Text()
+		if line == "" || line[0] == '#' {
+			continue
+		}
+
 		split := strings.SplitN(line, "=", 2)
 		if len(split) != 2 {
 			return fmt.Errorf("invalid line %q, want name=query", line)
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-05 13:44:17 +0000
20 15:17:52 +0200 committer arg@10ksloc.org <unknown> 2006-07-20 15:17:52 +0200 cleaned the CUSTOMIZE flags' href='/acidbong/suckless/dwm/commit/event.c?h=musl&id=2b5553b1ebf7c8e59b5ecf7128b932115ff2b313'>2b5553b ^ 
3af6434 ^

29355bd ^

c09bf8d ^



c09bf8d ^



dc5d967 ^

c09bf8d ^

1173723 ^


77f8c07 ^

dc5d967 ^

c09bf8d ^



77f8c07 ^

c09bf8d ^






e6cbe9c ^

1173723 ^


c53980c ^

c09bf8d ^











c09bf8d ^

c53980c ^

dc5d967 ^

c09bf8d ^

1173723 ^


77f8c07 ^

c09bf8d ^


1173723 ^

c09bf8d ^

77f8c07 ^

c09bf8d ^






e6cbe9c ^

1173723 ^




8af1d97 ^




c53980c ^

c09bf8d ^







29355bd ^


b9da4b0 ^


29355bd ^


b9da4b0 ^

dc5d967 ^

b9da4b0 ^

29355bd ^

901b3ed ^



b355755 ^

901b3ed ^





29355bd ^

901b3ed ^


b01a51a ^

901b3ed ^


b01a51a ^

901b3ed ^

29355bd ^


6458d72 ^

4bd0d33 ^

7b5638f ^

b9da4b0 ^




4bd0d33 ^






b9da4b0 ^


4bd0d33 ^

c53980c ^

b9da4b0 ^






439e15d ^


dc5d967 ^

439e15d ^

95e8d12 ^

439e15d ^

95e8d12 ^

439e15d ^

b9da4b0 ^

2e836ec ^

6a39a49 ^








2e836ec ^

95e8d12 ^

2e836ec ^

95e8d12 ^





















6a39a49 ^

b098c94 ^




95e8d12 ^










6a39a49 ^

95e8d12 ^

439e15d ^





439e15d ^



26e134b ^


439e15d ^





439e15d ^

dc5d967 ^

439e15d ^

b79b5fa ^

439e15d ^


1d85225 ^

3399650 ^

dfd84f9 ^

da2bbd3 ^

439e15d ^



439e15d ^


83d2390 ^

dc5d967 ^

439e15d ^


59b4a5e ^

c0705ee ^

dba2306 ^

c0705ee ^

439e15d ^




adaa28a ^


0464e42 ^

adaa28a ^


dc5d967 ^

adaa28a ^



3af6434 ^


adaa28a ^
















439e15d ^


439e15d ^

dc5d967 ^

439e15d ^










0053620 ^


439e15d ^





439e15d ^

dc5d967 ^


439e15d ^




3399650 ^

c09bf8d ^

dba2306 ^

b1701ad ^


3399650 ^



66da153 ^

901b3ed ^

66da153 ^

3399650 ^


c0705ee ^

3399650 ^


c09bf8d ^

c0705ee ^


3399650 ^


439e15d ^





439e15d ^



0053620 ^


439e15d ^

adaa28a ^

bf35794 ^

adaa28a ^

















0464e42 ^

adaa28a ^





adaa28a ^


3af6434 ^


a73a882 ^




adaa28a ^


1
2
3
4

5

6

7

8

9

10

11
12
13
14
15
16
17
18

19

20

21

22

23
24
25

26
27
28

29

30

31
32

33

34

35
36
37

38

39
40
41
42
43
44

45

46
47

48

49
50
51
52
53
54
55
56
57
58
59

60

61

62

63

64
65

66

67
68

69

70

71

72
73
74
75
76
77

78

79
80
81
82

83
84
85
86

87

88
89
90
91
92
93
94

95
96

97
98

99
100

101

102

103

104

105
106
107

108

109
110
111
112
113

114

115
116

117

118
119

120

121

122
123

124

125

126

127
128
129
130

131
132
133
134
135
136

137
138

139

140

141
142
143
144
145
146

147
148

149

150

151

152

153

154

155

156

157
158
159
160
161
162
163
164

165

166

167

168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

189

190
191
192
193

194
195
196
197
198
199
200
201
202
203

204

205

206
207
208
209
210

211
212
213

214
215

216
217
218
219
220

221

222

223

224

225
226

227

228

229

230

231
232
233

234
235

236

237

238
239

240

241

242

243

244
245
246
247

248
249

250

251
252

253

254
255
256

257
258

259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274

275
276

277

278

279
280
281
282
283
284
285
286
287
288

289
290

291
292
293
294
295

296

297
298

299
300
301
302

303

304

305

306
307

308
309
310

311

312

313

314
315

316

317
318

319

320
321

322
323

324
325
326
327
328

329
330
331

332
333

334

335

336

337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353

354

355
356
357
358
359

360
361

362
363

364
365
366
367

368
369




                                                              
                
                   
                       
                      
 
            







                               
    
 
                                                          
 


                    


                                 
                  
 

                   
                                                                                  
                                                                           


                                                                           
                                                               





                                             
                                          

                                                         
                                                  










                                                         
                     
                      
                  
 

                   
                                                                                  

                                                                                     
                                                                
                 
                                                               





                                             
                                          



                                                                        



                                                                                     
                                                






                                                         

           

                      

              
                  
                                              
 
                                  


                                    
                                                          




                                                      
                         

                              
                                     

                              
                                     
                              

                 
                                              
                          
                         



                                    





                                                                           

                              
                                                                           
                                               





                              

                           
                  
                                                           
                     
                          
                              
 
                                         
                                   







                                             
                                                  
                                                     
                                    




















                                                                                        
                                  



                                                  









                                                                       
                                  
         




                        


                                                     

                                       




                      
                  
                                           
 
                                                                    

                       
                                                                      
                         
                                   
                             


           

                 
                  
                                       

                            
                                        
                                     
                                                    
                                     



           

                   
                                                               

                       
                                 


                                                                

                                                                                















                                                         

                     
                                    
                                               









                                                                            

                                        




                         
                  

                                           



                                       
                                         
                                                     
                                                    

                               


                                                 
                                                                          
                                                                              
                                                      

                                                
                                           

                                      
                                                                              

                                     

                 




                      


                                     

                                       
 
 
            
















                                              
                                                               




                                                            

                                                              

                                                                      



                                                                                    

         
/*
 * (C)opyright MMVI Anselm R. Garbe <garbeam at gmail dot com>
 * See LICENSE file for license details.
 */
#include "dwm.h"
#include <stdlib.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>

/* static */

typedef struct {
	unsigned long mod;
	KeySym keysym;
	void (*func)(Arg *arg);
	Arg arg;
} Key;

KEYS

#define CLEANMASK(mask) (mask & ~(NUMLOCKMASK | LockMask))

static void
movemouse(Client *c)
{
	int x1, y1, ocx, ocy, di;
	unsigned int dui;
	Window dummy;
	XEvent ev;

	ocx = c->x;
	ocy = c->y;
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
			None, cursor[CurMove], CurrentTime) != GrabSuccess)
		return;
	XQueryPointer(dpy, root, &dummy, &dummy, &x1, &y1, &di, &di, &dui);
	for(;;) {
		XMaskEvent(dpy, MOUSEMASK | ExposureMask, &ev);
		switch (ev.type) {
		default: break;
		case Expose:
			handler[Expose](&ev);
			break;
		case MotionNotify:
			XSync(dpy, False);
			c->x = ocx + (ev.xmotion.x - x1);
			c->y = ocy + (ev.xmotion.y - y1);
			resize(c, False, TopLeft);
			break;
		case ButtonRelease:
			XUngrabPointer(dpy, CurrentTime);
			return;
		}
	}
}

static void
resizemouse(Client *c)
{
	int ocx, ocy;
	Corner sticky;
	XEvent ev;

	ocx = c->x;
	ocy = c->y;
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
				None, cursor[CurResize], CurrentTime) != GrabSuccess)
		return;
	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w, c->h);
	for(;;) {
		XMaskEvent(dpy, MOUSEMASK | ExposureMask, &ev);
		switch(ev.type) {
		default: break;
		case Expose:
			handler[Expose](&ev);
			break;
		case MotionNotify:
			XSync(dpy, False);
			c->w = abs(ocx - ev.xmotion.x);
			c->h = abs(ocy - ev.xmotion.y);
			c->x = (ocx <= ev.xmotion.x) ? ocx : ocx - c->w;
			c->y = (ocy <= ev.xmotion.y) ? ocy : ocy - c->h;
			if(ocx <= ev.xmotion.x)
				sticky = (ocy <= ev.xmotion.y) ? TopLeft : BotLeft;
			else
				sticky = (ocy <= ev.xmotion.y) ? TopRight : BotRight;
			resize(c, True, sticky);
			break;
		case ButtonRelease:
			XUngrabPointer(dpy, CurrentTime);
			return;
		}
	}
}

static void
buttonpress(XEvent *e)
{
	int x;
	Arg a;
	Client *c;
	XButtonPressedEvent *ev = &e->xbutton;

	if(barwin == ev->window) {
		switch(ev->button) {
		default:
			x = 0;
			for(a.i = 0; a.i < ntags; a.i++) {
				x += textw(tags[a.i]);
				if(ev->x < x) {
					view(&a);
					break;
				}
			}
			break;
		case Button4:
			viewnext(&a);
			break;
		case Button5:
			viewprev(&a);
			break;
		}
	}
	else if((c = getclient(ev->window))) {
		higher(c);
		focus(c);
		switch(ev->button) {
		default:
			break;
		case Button1:
			if(!c->ismax && (arrange == dofloat || c->isfloat))
				movemouse(c);
			break;
		case Button2:
			if(!c->ismax && arrange != dofloat && !c->isfloat)
				zoom(NULL);
			break;
		case Button3:
			if(!c->ismax && (arrange == dofloat || c->isfloat))
				resizemouse(c);
			break;
		}
	}
}

static void
configurerequest(XEvent *e)
{
	Client *c;
	XConfigureRequestEvent *ev = &e->xconfigurerequest;
	XEvent synev;
	XWindowChanges wc;
	unsigned long newmask;

	if((c = getclient(ev->window))) {
		gravitate(c, True);
		if(ev->value_mask & CWX)
			c->x = ev->x;
		if(ev->value_mask & CWY)
			c->y = ev->y;
		if(ev->value_mask & CWWidth)
			c->w = ev->width;
		if(ev->value_mask & CWHeight)
			c->h = ev->height;
		if(ev->value_mask & CWBorderWidth)
			c->border = ev->border_width;
		gravitate(c, False);
		wc.x = c->x;
		wc.y = c->y;
		wc.width = c->w;
		wc.height = c->h;
		newmask = ev->value_mask & (~(CWSibling | CWStackMode | CWBorderWidth));
		if(newmask)
			XConfigureWindow(dpy, c->win, newmask, &wc);
		else {
			synev.type = ConfigureNotify;
			synev.xconfigure.display = dpy;
			synev.xconfigure.event = c->win;
			synev.xconfigure.window = c->win;
			synev.xconfigure.x = c->x;
			synev.xconfigure.y = c->y;
			synev.xconfigure.width = c->w;
			synev.xconfigure.height = c->h;
			synev.xconfigure.border_width = c->border;
			synev.xconfigure.above = None;
			/* Send synthetic ConfigureNotify */
			XSendEvent(dpy, c->win, True, NoEventMask, &synev);
		}
		XSync(dpy, False);
		if(c->isfloat)
			resize(c, False, TopLeft);
		else
			arrange(NULL);
	}
	else {
		wc.x = ev->x;
		wc.y = ev->y;
		wc.width = ev->width;
		wc.height = ev->height;
		wc.border_width = ev->border_width;
		wc.sibling = ev->above;
		wc.stack_mode = ev->detail;
		XConfigureWindow(dpy, ev->window, ev->value_mask, &wc);
		XSync(dpy, False);
	}
}

static void
destroynotify(XEvent *e)
{
	Client *c;
	XDestroyWindowEvent *ev = &e->xdestroywindow;

	if((c = getclient(ev->window)))
		unmanage(c);
}

static void
enternotify(XEvent *e)
{
	Client *c;
	XCrossingEvent *ev = &e->xcrossing;

	if(ev->mode != NotifyNormal || ev->detail == NotifyInferior)
		return;

	if((c = getclient(ev->window)) || (c = getctitle(ev->window)))
		focus(c);
	else if(ev->window == root)
		issel = True;
}

static void
expose(XEvent *e)
{
	Client *c;
	XExposeEvent *ev = &e->xexpose;

	if(ev->count == 0) {
		if(barwin == ev->window)
			drawstatus();
		else if((c = getctitle(ev->window)))
			drawtitle(c);
	}
}

static void
keypress(XEvent *e)
{
	static unsigned int len = sizeof(key) / sizeof(key[0]);
	unsigned int i;
	KeySym keysym;
	XKeyEvent *ev = &e->xkey;

	keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
	for(i = 0; i < len; i++)
		if(keysym == key[i].keysym &&
				CLEANMASK(key[i].mod) == CLEANMASK(ev->state)) {
			if(key[i].func)
				key[i].func(&key[i].arg);
			return;
		}
}

static void
leavenotify(XEvent *e)
{
	XCrossingEvent *ev = &e->xcrossing;

	if((ev->window == root) && !ev->same_screen)
		issel = True;
}

static void
maprequest(XEvent *e)
{
	static XWindowAttributes wa;
	XMapRequestEvent *ev = &e->xmaprequest;

	if(!XGetWindowAttributes(dpy, ev->window, &wa))
		return;

	if(wa.override_redirect) {
		XSelectInput(dpy, ev->window,
				(StructureNotifyMask | PropertyChangeMask));
		return;
	}

	if(!getclient(ev->window))
		manage(ev->window, &wa);
}

static void
propertynotify(XEvent *e)
{
	Client *c;
	Window trans;
	XPropertyEvent *ev = &e->xproperty;

	if(ev->state == PropertyDelete)
		return; /* ignore */

	if((c = getclient(ev->window))) {
		if(ev->atom == wmatom[WMProtocols]) {
			c->proto = getproto(c->win);
			return;
		}
		switch (ev->atom) {
			default: break;
			case XA_WM_TRANSIENT_FOR:
				XGetTransientForHint(dpy, c->win, &trans);
				if(!c->isfloat && (c->isfloat = (trans != 0)))
					arrange(NULL);
				break;
			case XA_WM_NORMAL_HINTS:
				setsize(c);
				break;
		}
		if(ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) {
			settitle(c);
			drawtitle(c);
		}
	}
}

static void
unmapnotify(XEvent *e)
{
	Client *c;
	XUnmapEvent *ev = &e->xunmap;

	if((c = getclient(ev->window)))
		unmanage(c);
}

/* extern */

void (*handler[LASTEvent]) (XEvent *) = {
	[ButtonPress] = buttonpress,
	[ConfigureRequest] = configurerequest,
	[DestroyNotify] = destroynotify,
	[EnterNotify] = enternotify,
	[LeaveNotify] = leavenotify,
	[Expose] = expose,
	[KeyPress] = keypress,
	[MapRequest] = maprequest,
	[PropertyNotify] = propertynotify,
	[UnmapNotify] = unmapnotify
};

void
grabkeys()
{
	static unsigned int len = sizeof(key) / sizeof(key[0]);
	unsigned int i;
	KeyCode code;

	for(i = 0; i < len; i++) {
		code = XKeysymToKeycode(dpy, key[i].keysym);
		XGrabKey(dpy, code, key[i].mod, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, key[i].mod | LockMask, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, key[i].mod | NUMLOCKMASK, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, key[i].mod | NUMLOCKMASK | LockMask, root, True,
				GrabModeAsync, GrabModeAsync);
	}
}