siproc

siproc.cpp (14546B)

---

 /*
  * A call-automation program spawning processes for each call.
  * Copyright © 2019 Dominik Schmidt
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include <pjsua2.hpp>
 #include <stdlib.h>
 #include <stdio.h>
 #include <iostream>
 #include <unistd.h>
 #include <signal.h>
 #include <sys/wait.h>
 #include <sys/epoll.h>
 
 struct EV{
 	int efd;
 
 	EV(){
 		efd = epoll_create1(0);
 		if(efd < 0){
 			throw "Could not create epoll fd";
 		}
 	}
 
 	~EV(){
 		close(efd);
 	}
 
 	void ev_add(int fd, void *data){
 		struct epoll_event ev = {0};
 
 		ev.events = EPOLLIN;
 		ev.data.ptr = data;
 		epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ev);
 	}
 
 	void ev_del(int fd){
 		epoll_ctl(efd, EPOLL_CTL_DEL, fd, NULL);
 	}
 
 	void *wait(int timeout){
 		struct epoll_event ev = {0};
 
 		ev.data.u64 = 0;
 		int ret = epoll_wait(efd, &ev, 1, timeout);
 		if(ret < 0){
 			throw "Could not wait on epollfd";
 		}
 		else if(ret == 0){
 			return NULL;
 		}
 		else{
 			return ev.data.ptr;
 		}
 	}
 
 	void *wait(){
 		return wait(-1);
 	}
 };
 
 ssize_t readall(int fd, char **buffer, size_t *buffer_length){
 	ssize_t ret = 0;
 	size_t offset = 0;
 
 	while((ret = read(fd, (*buffer + offset), *buffer_length - offset)) == *buffer_length - offset){
 		*buffer_length *= 2;
 		*buffer = (char *)realloc(*buffer, *buffer_length);
 		offset += ret;
 	}
 	if(ret == -1){
 		PJ_LOG(1, ("Failed to read from fd: %s\n"\
 		"ADDRESS: %p, %lu\n", strerror(errno), *buffer, *buffer_length));
 		return -1;
 	}
 	return offset + ret;
 }
 
 
 EV ev_table = EV();
 
 using namespace pj;
 
 Endpoint ep;
 
 class MyAccount;
 class MyCall;
 
 class MyAudioMediaPlayer : public AudioMediaPlayer {
 	MyCall* call;
 	public:
 	char* path;
 	MyAudioMediaPlayer(MyCall* c, char *what) : AudioMediaPlayer(){
 		call = c;
 		path = what;
 	}
 
 	virtual bool onEof();
 };
 
 class MyCall: public Call{
 	FILE *c_stdin;
 	int c_stdout;
 	MyAccount *myacc;
 	pid_t child;
 	char *line;
 	size_t line_length;
 	std::vector<MyAudioMediaPlayer*> players;
 	std::map<int,ExtraAudioDevice*> audio_devs;
 	AudioMediaRecorder* recorder=NULL;
 	public:
 		MyCall(Account &acc, int call_id = PJSUA_INVALID_ID) : Call(acc, call_id){
 			c_stdin = NULL;
 			c_stdout = -1;
 			child = -1;
 			line = (char *)malloc(256);
 			line_length = 256;
 		}
 
 		~MyCall(){
 			if(line != NULL){
 				free(line);
 				line = NULL;
 				line_length = 0;
 			}
 			if(child != -1){
 				fork_off();
 			}
 			for(unsigned int i=0; i<players.size(); i++){
 				delete players[i];
 			}
 
 			for(auto it = audio_devs.begin(); it != audio_devs.end(); it++){
 				delete it->second;
 			}
 			audio_devs.clear();
 
 			if(recorder != NULL){
 				delete recorder;
 				recorder = NULL;
 			}
 		}
 
 		AudioMedia& call_audio(){
 			//return Endpoint::instance().audDevManager().getPlaybackDevMedia();
 			CallInfo ci = getInfo();
 			AudioMedia *aud_med = NULL;
 
 			// Find out which media index is the audio
 			for(unsigned i = 0; i < ci.media.size(); ++i){
 				if(ci.media[i].type == PJMEDIA_TYPE_AUDIO){
 					aud_med = (AudioMedia *)getMedia(i);
 					break;
 				}
 			}
 
 			return *aud_med;
 		}
 
 		void fork_off(){
 			if(child == -1){
 				return;
 			}
 			PJ_LOG(3, ("MyCall", "Shutting down child process"));
 			ev_table.ev_del(c_stdout);
 			fclose(c_stdin);
 			close(c_stdout);
 			c_stdin = NULL;
 			c_stdout = -1;
 			kill(child, SIGTERM);
 			int statloc;
 			waitpid(child, &statloc, 0);
 			child = -1;
 		}
 
 		void fork_on(char **args, bool outgoing);
 
 		virtual void onCallState(OnCallStateParam &prm){
 			CallInfo ci = getInfo();
 
 			if(ci.state == PJSIP_INV_STATE_DISCONNECTED){
 				fork_off();
 				delete this;
 				return;
 			}
 			else if(ci.state == PJSIP_INV_STATE_CONFIRMED){
 				command("CONNECTED\n");
 			}
 		}
 		
 		bool connected(){
 			CallInfo ci = getInfo();
 			return ci.state == PJSIP_INV_STATE_CONFIRMED;
 		}
 
 		bool onPlayerFinished(char *path, MyAudioMediaPlayer* who){
 			command("STOPPED %s\n", path);
 			delete who;
 			for(unsigned int i=0; i<players.size(); i++){
 				if(players[i] == who){
 					players.erase(players.begin()+i);
 				}
 			}
 			return false;
 		}
 
 		int command(const char *cmd, ...){
 			if(c_stdin == NULL){
 				return -1;
 			}
 			int ret;
 			va_list ap;
 			va_start(ap, cmd);
 			ret = vfprintf(c_stdin, cmd, ap);
 			va_end(ap);
 			fflush(c_stdin);
 			return ret;
 		}
 
 		virtual void onDtmfDigit(OnDtmfDigitParam &prm){
 			command("DTMF %s\n", prm.digit.c_str());
 		}
 
 		virtual void onInstantMessage(OnInstantMessageParam &prm){
 			command("MESSAGE %s\n", prm.msgBody.c_str());
 		}
 
 		void cmd_hangup(){
 			// Just hangup for now
 			CallOpParam op;
 
 			op.statusCode = PJSIP_SC_DECLINE;
 			hangup(op);
 		}
 
 		void cmd_answer(){
 			CallOpParam prm;
 
 			prm.statusCode = PJSIP_SC_OK;
 			answer(prm);
 		}
 
 		void cmd_dtmf(char *args){
 			dialDtmf(args);
 		}
 
 		void cmd_message(char *msg){
 			SendInstantMessageParam prm = SendInstantMessageParam();
 
 			prm.content = std::string(msg);
 			sendInstantMessage(prm);
 		}
 
 		void cmd_play(char *path){
 			AudioMedia& play_dev_med = call_audio();
 
 			MyAudioMediaPlayer* player = new MyAudioMediaPlayer(this, path);
 			try {
 				player->createPlayer(path, PJMEDIA_FILE_NO_LOOP);
 				player->startTransmit(play_dev_med);
 			}
 			catch(Error& err){
 				//std::cerr << err <<std::endl;
 			}
 			players.push_back(player);
 		}
 
 		void cmd_record(char *path){
 			AudioMedia& cap_dev_med = call_audio();
 			if(recorder != NULL){
 				cap_dev_med.stopTransmit(*recorder);
 				delete recorder;
 				recorder = NULL;
 			}
 
 			if(path != NULL){
 				recorder = new AudioMediaRecorder();
 				recorder->createRecorder(path);
 				cap_dev_med.startTransmit(*recorder);
 			}
 		}
 
 		void cmd_stop(char *path){
 			if(players.size()>0){
 				AudioMedia& play_dev_med = call_audio();
 
 				MyAudioMediaPlayer* player = players.back();
 				player->stopTransmit(play_dev_med);
 				onPlayerFinished(player->path, player);
 			}
 		}
 
 		void cmd_ringing(){
 			CallOpParam prm;
 
 			prm.statusCode = PJSIP_SC_RINGING;
 			answer(prm);
 		}
 
 		void cmd_transfer(char *number){
 			CallOpParam prm;
 
 			prm.statusCode = PJSIP_SC_RINGING;
 			xfer(std::string(number), prm);
 		}
 
 		int get_dev_id(char *devname){
 			AudDevManager &adm = ep.audDevManager();
 			return adm.lookupDev("ALSA", string(devname));
 		}
 
 		ExtraAudioDevice* get_extra_audio(char *devname){
 			int id = get_dev_id(devname);
 			ExtraAudioDevice *dev = NULL;
 			auto res = audio_devs.find(id);
 			if(res == audio_devs.end()){
 				dev = new ExtraAudioDevice(id,id);
 				audio_devs[id] = dev;
 				dev->open();
 			}
 			else{
 				dev = res->second;
 			}
 			return dev;
 		}
 
 		void cmd_aplay(char *source){
 			ExtraAudioDevice *ea = get_extra_audio(source);
 			AudioMedia& play_dev_med = call_audio();
 			ea->startTransmit(play_dev_med);
 		}
 
 		void cmd_arecord(char *sink){
 			ExtraAudioDevice *ea = get_extra_audio(sink);
 			AudioMedia& play_dev_med = call_audio();
 			play_dev_med.startTransmit(*ea);
 		}
 
 		void cmd_astop(char *sourcesink){
 			int id = get_dev_id(sourcesink);
 			auto res = audio_devs.find(id);
 			if(res == audio_devs.end()){
 				return;
 			}
 			ExtraAudioDevice *ea = res->second;
 			delete ea;
 			audio_devs.erase(res);
 		}
 
 
 		void command_machine(char *command){
 			char *args = strstr(command, " ");
 
 			if(args != NULL){
 				*args++ = '\0';
 			}
 			if(strcmp(command, "HANGUP") == 0){
 				cmd_hangup();
 			}
 			else if(strcmp(command, "ANSWER") == 0){
 				cmd_answer();
 			}
 			else if(strcmp(command, "RINGING") == 0){
 				cmd_ringing();
 			}
 			else if(!connected()){
 				PJ_LOG(2, ("MyCall", "Command %s coming at an inopportune time...", command));
 			}
 			else if(strcmp(command, "DTMF") == 0){
 				cmd_dtmf(args);
 			}
 			else if(strcmp(command, "MESSAGE") == 0){
 				cmd_message(args);
 			}
 			else if(strcmp(command, "PLAY") == 0){
 				cmd_play(args);
 			}
 			else if(strcmp(command, "STOP") == 0){
 				cmd_stop(args);
 			}
 			else if(strcmp(command, "RECORD") == 0){
 				cmd_record(args);
 			}
 			else if(strcmp(command, "TRANSFER") == 0){
 				cmd_transfer(args);
 			}
 			else if(strcmp(command, "APLAY") == 0){
 				cmd_aplay(args);
 			}
 			else if(strcmp(command, "ARECORD") == 0){
 				cmd_arecord(args);
 			}
 			else if(strcmp(command, "ASTOP") == 0){
 				cmd_astop(args);
 			}
 		}
 
 		void handle_line(){
 			PJ_LOG(3, ("MyCall", "Handling line"));
 			ssize_t ret = readall(c_stdout, &line, &line_length);
 			PJ_LOG(6, ("MyCall", "Read %lu bytes", ret));
 			if(ret < 0){
 				throw "Error reading from stdout";
 			}
 			else if(ret == 0){
 				PJ_LOG(3, ("MyCall", "Child closed stdout, killing it"));
 				fork_off();
 			}
 			else{
 				char *begin = line;
 				while(begin){
 					char *end = strstr(begin, "\n");
 					if(end != NULL){
 						*end = '\0';
 					}
 					command_machine(begin);
 					begin = end;
 				}
 			}
 		}
 };
 
 bool MyAudioMediaPlayer::onEof(){
 	return call->onPlayerFinished(path, this);
 }
 
 
 class MyAccount: public Account{
 	public:
 		char **args;
 		MyAccount(char **args){
 			this->args = args;
 		}
 		~MyAccount(){
 		}
 
 		virtual void onIncomingCall(OnIncomingCallParam &iprm){
 			MyCall *call = new MyCall(*this, iprm.callId);
 
 			call->fork_on(args, false);
 		}
 };
 
 void MyCall::fork_on(char **args, bool outgoing){
 	PJ_LOG(4, ("MyCall", "Setting up Fork"));
 	int pipes_stdin[2], pipes_stdout[2];
 
 	if(pipe(pipes_stdin) != 0){
 		throw "Pipe creation failed";
 	}
 
 	if(pipe(pipes_stdout) != 0){
 		throw "Pipe creation failed";
 	}
 	c_stdin = fdopen(pipes_stdin[1], "w");
 	setvbuf(c_stdin, NULL, _IOLBF, 256);
 	c_stdout = pipes_stdout[0];
 
 	CallInfo ci = getInfo();
 	PJ_LOG(4, ("MyCall", "Calling fork"));
 	pid_t pid = fork();
 	if(pid == -1){
 		PJ_LOG(1, ("MyCall", "Fork failed"));
 		throw "Fork failed";
 	}
 	else if(pid == 0){
 		dup2(pipes_stdin[0], STDIN_FILENO);
 		dup2(pipes_stdout[1], STDOUT_FILENO);
 		close(pipes_stdin[1]);
 		close(pipes_stdout[0]);
 		setenv("SIPROC_REMOTE_ID", ci.callIdString.c_str(), 1);
 		setenv("SIPROC_REMOTE_URI", ci.remoteUri.c_str(), 1);
 		setenv("SIPROC_REMOTE_CONTACT", ci.remoteContact.c_str(), 1);
 		setenv("SIPROC_OUTGOING", (outgoing) ? "y" : "n", 1);
 		if(execv(args[0], args) < 0){
 			perror("exec");
 		}
 		exit(1);
 	}
 	else{
 		PJ_LOG(3, ("MyCall", "Fork successfull"));
 		child = pid;
 		close(pipes_stdin[0]);
 		close(pipes_stdout[1]);
 		ev_table.ev_add(pipes_stdout[0], this);
 	}
 }
 
 const char* env_or_default(const char* name, const char* default_value){
 	char *env = getenv(name);
 	if(env == NULL){
 		return default_value;
 	}
 	return env;
 }
 
 void usage(){
 	fprintf(stderr,
 			"Usage: siproc <executable> [args...]\n\n"
 			"Make sure to define the following environment variables:\n"
 			"\t* SIPROC_USERNAME:\tThe username used for authentication, e.g. Foo\n"
 			"\t* SIPROC_PASSWORD:\tThe password used for authentication, e.g. Bar\n"
 			"\t* SIPROC_REGISTRAR_URI:\tThe server to connect to, e.g. \"sip:fritz.box\"\n"
 			"\t* SIPROC_ID_URI:\tThe ID URI of your account, e.g. \"Foo Baz <sip:Foo@fritz.box>\"\n"
 			"\nThanks for riding siproc!\n"
 			);
 }
 
 int main(int argc, char **argv){
 	char *user, *password, *idUri, *reguri;
 
 	if(!(user = getenv("SIPROC_USERNAME"))){
 		fprintf(stderr, "SIPROC_USERNAME not in environment variables\n\n");
 		usage();
 		return 1;
 	}
 	if(!(password = getenv("SIPROC_PASSWORD"))){
 		fprintf(stderr, "SIPROC_PASSWORD not in environment variables\n\n");
 		usage();
 		return 1;
 	}
 
 	if(!(reguri = getenv("SIPROC_REGISTRAR_URI"))){
 		fprintf(stderr, "SIPROC_REGISTRAR_URI not in environment variables\n\n");
 		usage();
 		return 1;
 	}
 
 	if(!(idUri = getenv("SIPROC_ID_URI"))){
 		fprintf(stderr, "SIPROC_ID_URI not in environment variables\n\n");
 		usage();
 		return 1;
 	}
 
 	try{
 		ep.libCreate();
 		EpConfig ep_cfg;
 		ep_cfg.logConfig.level = atoi(env_or_default("SIPROC_LOG_LEVEL", "2"));;
 		ep.libInit(ep_cfg);
 		
 		char *codec_prios;
 		if((codec_prios = getenv("SIPROC_CODEC_PRIORITIES"))){
 			
 			while(codec_prios != NULL){
 				char *name = codec_prios;
 				codec_prios = strstr(codec_prios, ",");
 				if(codec_prios != NULL){
 					*codec_prios++='\0';
 				}
 				char *prio = strstr(name, ":");
 				if(prio == NULL){
 					PJ_LOG(1, ("Main", "Codecs string malformed. Should be <name>:<prio>[,<name>:<prio>...]"));
 					return 1;
 				}
 				*prio++='\0';
 				int prio_i = atoi(prio);
 				if(prio_i < 0 || prio_i > 255){
 					PJ_LOG(1, ("Main", "Codec priority must be in [0,255]"));
 				}
 				ep.codecSetPriority(string(name), prio_i);
 			}
 		}
 		
 		AudDevManager &adm = ep.audDevManager();
 		adm.setNullDev();
 
 		TransportConfig tcfg;
 		tcfg.port = atoi(env_or_default("SIPROC_TRANSPORT_PORT", "5060"));
 		try {
 			ep.transportCreate(PJSIP_TRANSPORT_UDP, tcfg);
 		} catch(Error &err){
 			PJ_LOG(1, ("Setup", "Error setting up transport: %s", err.info().c_str()));
 			return 1;
 		}
 
 		ep.libStart();
 
 
 		AccountConfig acfg;
 		acfg.idUri = idUri;
 		acfg.regConfig.registrarUri = reguri;
 		AuthCredInfo cred("digest", "*", user, 0, password);
 		acfg.sipConfig.authCreds.push_back(cred);
 
 		MyAccount *acc = new MyAccount(&argv[1]);
 		acc->create(acfg);
 
 		char *line = NULL;
 		size_t line_length = 0;
 		ev_table.ev_add(STDIN_FILENO, &line_length);
 		while(void *ptr = ev_table.wait()){
 			if(ptr == &line_length){
 				ssize_t bytes = getline(&line, &line_length, stdin);
 				if(bytes > 0){
 					line[--bytes] = '\0';
 					PJ_LOG(6, ("Main", "Got line with length %lu: %s", bytes, line));
 					size_t cmdlen=line_length;
 					char *args = strstr(line, " ");
 					if(args){
 						line_length -= args-line;
 						*args++ = '\0';
 					}
 
 					if(strncmp(line, "QUIT", cmdlen) == 0){
 						break;
 					}
 					else if(strncmp(line, "CALL", cmdlen) == 0){
 						PJ_LOG(4, ("Main", "Placing call to %s", args));
 						MyCall *mc = new MyCall(*acc);
 						CallOpParam prm(true);
 						try{
 							mc->makeCall(std::string(args), prm);
 							mc->fork_on(acc->args, true);
 						}
 						catch(Error& err) {
 						}
 					}
 				}
 			}
 			else{
 				MyCall *c = (MyCall *)ptr;
 				c->handle_line();
 			}
 		}
 		delete acc;
 	}
 	catch(char const *c){
 		PJ_LOG(1, ("Main", "Fatal Exception: %s",c));
 	}
 
 	return 0;
 }