Lower thread stack to 128k

camd.c

 		c->req_queue = queue_new();
 		c->ecm_queue = queue_new();
 		c->emm_queue = queue_new();
-		pthread_create(&c->thread, NULL , &camd_thread, ts);
+		pthread_create(&c->thread, &ts->thread_attr , &camd_thread, ts);
 	}
 }
 

data.c

 	ts->write_buf   = cbuf_init((7 * dvbcsa_bs_batch_size() * 188) *  8, "write");  // ~324Kb
 
 	ts->input_buffer= list_new("input");
+
+	pthread_attr_init(&ts->thread_attr);
+	size_t stack_size;
+	pthread_attr_getstacksize(&ts->thread_attr, &stack_size);
+	if (stack_size > THREAD_STACK_SIZE)
+		pthread_attr_setstacksize(&ts->thread_attr, THREAD_STACK_SIZE);
 }
 
 void data_free(struct ts *ts) {
 	// and in order to avoid leaking 43 bytes of memory on exit which makes valgrind
 	// unhappy it is a good idea to free the memory (ONCE!).
 	FREE(ts->camd.newcamd.crypt_passwd);
+
+	pthread_attr_destroy(&ts->thread_attr);
 }

data.h

 #define ECM_QUEUE_HARD_LIMIT 10
 #define ECM_QUEUE_SOFT_LIMIT 3
 
+// 64k should be enough for everybody
+#define THREAD_STACK_SIZE (64 * 1024)
+
 struct notify {
 	pthread_t	thread;				/* Thread handle */
 	QUEUE		*notifications;		/* Notification queue */
 
 	int					threaded;
 
+	pthread_attr_t		thread_attr;
+
 	int					decode_stop;
 	pthread_t			decode_thread;
 	CBUF				*decode_buf;

notify.c

 	}
 	strncpy(n->program, ts->notify_program, sizeof(n->program) - 1);
 	n->program[sizeof(n->program) - 1] = '\0';
-	pthread_create(&n->thread, NULL , &notify_thread, n);
+	pthread_create(&n->thread, &ts->thread_attr , &notify_thread, n);
 	return n;
 }
 

tsdecrypt.c

 #include <fcntl.h>
 #include <errno.h>
 #include <syslog.h>
+#include <sys/resource.h>
 
 #include <dvbcsa/dvbcsa.h>
 #include <openssl/rand.h>
 	int ntimeouts = 0;
 	time_t timeout_start = time(NULL);
 	int rtp_hdr_pos = 0, num_packets = 0;
+	struct rlimit rl;
+
+	if (getrlimit(RLIMIT_STACK, &rl) == 0) {
+		if (rl.rlim_cur > THREAD_STACK_SIZE) {
+			rl.rlim_cur = THREAD_STACK_SIZE;
+			setrlimit(RLIMIT_STACK, &rl);
+		}
+	}
 
 	memset(rtp_hdr[0], 0, RTP_HDR_SZ);
 	memset(rtp_hdr[1], 0, RTP_HDR_SZ);
 	signal(SIGTERM, signal_quit);
 
 	if (ts.threaded) {
-		pthread_create(&ts.decode_thread, NULL, &decode_thread, &ts);
-		pthread_create(&ts.write_thread, NULL , &write_thread , &ts);
+		pthread_create(&ts.decode_thread, &ts.thread_attr, &decode_thread, &ts);
+		pthread_create(&ts.write_thread , &ts.thread_attr, &write_thread , &ts);
 	}
 
 	ts.emm_last_report = time(NULL) + FIRST_REPORT_SEC;