Esempio n. 1
0
int main (int argc, char* argv[])
{

	// SIG handling

	signal(SIGINT, sig);
	signal(SIGTERM, sig);
	atexit(destroy);

	// init logging

	setlogmask (LOG_UPTO (LOG_INFO));
	openlog ("zenith", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);

	syslog (LOG_INFO, "Version %s started", ZENITH_VERSION);

	init_config("configuration.conf");
	init_mysql();

	strncpy(uuid, argv[1], 50);

	syslog (LOG_INFO, "UUID: %s", uuid);

	zenith_map_active_signatures();

	return 0;
}
Esempio n. 2
0
//***********************************************
//----------------------------------------------------------------------
//!\brief           le main !
//----------------------------------------------------------------------
//***********************************************
int main() {  

	//***************************
	//* INITIALISATION
	//***************************
	printf("Installing signal handler...");
	(void) signal(SIGINT, sigfun);
	printf("done\n");


	//lecture de la date/heure courante
	// on récupère l'heure courante au format UNIX -> nb de secondes depuis le 01/01/1970 , je fais comme ça car c'est plus facile que de comparer des dates/heure
	// seconds = nb de secondes depuis le 1er janvier 1970
	// conversion en heure locale
	struct tm *local;
	time_t t;
	t = time(NULL);
	// conversion en heure locale
	local = localtime(&t);
	printf("Heure et date courante : %s\n", asctime(local));
	
	  
	//***************************************************************************
	//* PROGRAMME PRINCIPAL 
	//***************************************************************************
	int i;
	
	for(i=0; i< NB_ELEMENT_TABLE; i++ ){
	
		//initialisation BDD
		if(init_mysql() == 1) {
			// erreur de liaison avec la bdd
			// prévoir un msg de log vers un fichier de log
			exit(1);
		}
	
		//DEBUG
		printf("\n Table concernee : %s", table[i]);
		
		//on supprime les donnees
		if(supp_donnees(table[i]) == 1) {
			// erreur de liaison avec la bdd
			// prévoir un msg de log vers un fichier de log
			exit(1);
		}
		
		// fermeture de MySQL
		mysql_close(conn);
	
	}
		
	// flush pour afficher tout les messages et debug
	fflush(stdout);

	printf("\nEXIT \n\n");

	//exit(0);
}
Esempio n. 3
0
/*
 * Usage: ./judged oj_home [debug]
 */
int main(int argc, char *argv[])
{
	DEBUG = (argc > 2);
	//如果第2个参数指定了家目录,就设置为那个目录
	//在debug时有用
	//否则默认为/home/judge
	if (argc > 1) {
		strcpy(oj_home, argv[1]);
	} else {
		strcpy(oj_home, "/home/judge");
	}

	chdir(oj_home);		// change the dir

	//不调试就设为守护进程
	if (!DEBUG) {
		daemon_init();
	}

	//进程已经运行了
	if (strcmp(oj_home, "/home/judge") == 0 && already_running()) {
		write_log("This daemon program is already running.\n");
		exit(EXIT_FAILURE);
	}

	init_mysql_conf();	// set the database info

	//设置信号的回调函数
	signal(SIGQUIT, call_for_exit);
	signal(SIGKILL, call_for_exit);
	signal(SIGTERM, call_for_exit);

	int j = 1;
	while (1) {		// start to run
		//从数据库中查询出来的没有判的题目判完
		//然后一直询问
		while (j && !init_mysql()) {
			j = work();
		}
		write_log("next query after %d seconds.\n", sleep_time);
		sleep(sleep_time);
		j = 1;
	}

	return 0;
}
Esempio n. 4
0
int download_ok (char *file, int fe_id) {
	/* Initialise MySQL connection */
	MYSQL *conn;
	static char query[QUERY_MAX];

	if ((conn = init_mysql(conn)) == NULL) {
		mysql_close(conn);
		error_log(ERROR,"MySQL initialisation failed");
		exit(EXIT_FAILURE);
	}

	if (!connect_mysql(conn)) {
		mysql_close(conn);
		error_log(ERROR,"MySQL connection failed");
		exit(EXIT_FAILURE);
	}
	sprintf(query,
			"INSERT INTO cached (id, fe_id, filename, cached_time) "
					"VALUES (md5('%s'), %d, '%s', now())",
			file, fe_id, file);
	query_mysql(conn, query);
	mysql_close(conn);
	return 0;
}
Esempio n. 5
0
//----------------------------------------------------------------------
//!\brief           le main !
//----------------------------------------------------------------------
int main(int argc, char *argv[]) {  
  
  //***************************
  //* INITIALISATION
  //***************************
  printf("Installing signal handler...");
  (void) signal(SIGINT, sigfun);
  printf("done\n");


  //initialisation BDD
  if(init_mysql() == 1) {
    // erreur de liaison avec la bdd
    // prévoir un msg de log vers un fichier de log
    exit(1);
  }
  
  //***************************************************************************
  //* PROGRAMME PRINCIPAL 
  //***************************************************************************

  //lecture de la date/heure courante
  // t = nb de secondes depuis le 1er janvier 1970
  t = time(NULL);  
  // conversion en heure locale
  local = localtime(&t); 
  printf("Heure et date courante : %s\n", asctime(local));
  printf("Heure et date courante (UNIX): %d\n", t);
  
  
  // récupération de la pile des messages 
  if(recup_pile_msg() == 1) {
    // erreur sur la recuperation des messages
    // prévoir un msg de log vers un fichier de log
    exit(1);
  }
  
  // pour chaque message
  while ((row = mysql_fetch_row(result))) {
  
    // on stocke la taille  dans le pointeur
    lengths = mysql_fetch_lengths(result);
    
    // on lit la date de création du message lu dans la pile
    read_date_msg();
      
    //si la date est récente ( <1 minute)
    if(t - time_unix_msg < TIMEOUTMSG) {
	
	  // on configure et on ouvre le port COM
	  if(ConfigOpenPortCOM(argc, argv) == 1) {
		// erreur nb de params ou ouverture du com port
		// prévoir un msg de log vers un fichier de log
		exit(1);
	  }
	
      // on envoie ce message vers la radio
      if(send_msg_to_radio() == 0) {
        // erreur sur la recuperation des messages
		printf("\nErreur sur envoi message, taille = %d", iTaille_msg);
        // prévoir un msg de log vers un fichier de log
      }
	  
		//fermeture du port COM
		close(fd);
	  
    }
    else {
      // on affiche un message d'avertissement
      printf("Message expire : %d sec.\n",t - time_unix_msg);
    }	
  }
  
	// on supprime tous les messages (dans tous les cas)
	if(delete_msg() == 1) {
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
	}    
  
  // libération du jeu de résultat
  mysql_free_result(result);

  // fermeture de MySQL
  mysql_close(conn);

  //exit(0);
}
Esempio n. 6
0
init ()
{
	char	*env, tmp[80], fname[200];
	int		key;

	/*
	if (nmsif_initLog () < 0)
		return -1;
	*/

	/* get environment variable (MY_SYS_NAME) */
	if ((env = getenv (MY_SYS_NAME)) == NULL) {
		sprintf (traceBuf, "not found %s env_variable\n", MY_SYS_NAME);
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	strcpy (mySysName, env);

	strcpy (myAppName, "NMSIF");
	commlib_setupSignals (NULL);

	if (nmsif_initLog () < 0)
		return -1;

	/* get environment variable (IV_HOME) */
	if ((env = getenv (IV_HOME)) == NULL) {
		sprintf (traceBuf, "not found %s env_variable\n", IV_HOME);
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	sprintf (fname, "%s/%s", env, SYSCONF_FILE);

	/* get environment variable (MY_SYS_ENTRY) */
	if ((env = getenv (MY_SYS_ENTRY)) == NULL) {
		sprintf (traceBuf, "not found %s env_variable\n", MY_SYS_ENTRY);
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	mySysEntry = atoi (env);

	if(set_proc_version(OMP_VER_INX_NMSIF, ver) < 0){
		sprintf (traceBuf, "setting process version failed\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}

	/* get rx message queue id */
	if (conflib_getNthTokenInFileSection (fname, "APPLICATIONS", "NMSIF", 1, tmp) < 0) {
		sprintf (traceBuf, "fail get keyword (nmsif)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	key = strtol (tmp, 0, 0);
	if ((nmsifQid = msgget (key, IPC_CREAT|0666)) < 0) {
		sprintf (traceBuf, "rx msgget fail : %s\n", strerror (errno));
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}

	/* get tx message queue id */
	if (conflib_getNthTokenInFileSection (fname, "APPLICATIONS", "IXPC", 1, tmp) < 0) {
		sprintf (traceBuf, "fail get keyword (ixpc)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	key = strtol (tmp, 0, 0);
	if ((ixpcQid = msgget (key, IPC_CREAT|0666)) < 0) {
		sprintf (traceBuf, "[*] tx msgget fail : %s\n", strerror (errno));
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}

	/* get shared memory pointer */
	if (conflib_getNthTokenInFileSection (fname, "SHARED_MEMORY_KEY", "SHM_SFDB", 1, tmp) < 0) {
		sprintf (traceBuf, "[*] fail get keyword (shm_sfdb)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	key = strtol (tmp, 0, 0);

	if (get_nms_con (key) < 0)
		return -1;

	/* get listen ipaddr */
	if (get_listen_ipaddr (fname) < 0)
		return -1;


	/* get listen port for NMS I/F ********************************
	 * -----------------------------------------------------------
	 *            Port   Purpose             Direction (BSD<->NMS)
	 * -----------------------------------------------------------
	 *  Console   5021   Alarm/Fault/Status    ->
	 *  Alarm     5023   Current Alarm        <->
	 *  Perform   5031   Statistics Data       ->
	 *  Config    5041   H/W, S/W Config      <->
	 *  MMC       5061   MMC In/Output        <->
	 **************************************************************/
	if (conflib_getNthTokenInFileSection (fname, "SOCKET_PORT", "NMS_ALM", 1, tmp) < 0) {
		sprintf (traceBuf, "fail get keyword (socket/alm_port)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	ne_info.port[PORT_IDX_ALM] = strtol (tmp, 0, 0);

	FD_ZERO (&rfd_set);
	FD_ZERO (&wfd_set);
	FD_ZERO (&efd_set);

	if (init_listen (PORT_IDX_ALM) < 0)
		return -1;


	if (conflib_getNthTokenInFileSection (fname, "SOCKET_PORT", "NMS_CONS", 1, tmp) < 0) {
		sprintf (traceBuf, "fail get keyword (socket/console_port)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	ne_info.port[PORT_IDX_CONS] = strtol (tmp, 0, 0);

	if (init_listen (PORT_IDX_CONS) < 0)
		return -1;


	if (conflib_getNthTokenInFileSection (fname, "SOCKET_PORT", "NMS_CONF", 1, tmp) < 0) {
		sprintf (traceBuf, "fail get keyword (socket/config_port)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	ne_info.port[PORT_IDX_CONF] = strtol (tmp, 0, 0);

	if (init_listen (PORT_IDX_CONF) < 0)
		return -1;

	if (conflib_getNthTokenInFileSection (fname, "SOCKET_PORT", "NMS_MMC", 1, tmp) < 0) {
		sprintf (traceBuf, "fail get keyword (socket/mmc_port)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	ne_info.port[PORT_IDX_MMC] = strtol (tmp, 0, 0);

	if (init_listen (PORT_IDX_MMC) < 0)
		return -1;

	if (conflib_getNthTokenInFileSection (fname, "SOCKET_PORT", "NMS_STAT", 1, tmp) < 0) {
		sprintf (traceBuf, "fail get keyword (socket/stat_port)\n");
		trclib_writeLogErr (FL, traceBuf);
		return -1;
	}
	ne_info.port[PORT_IDX_STAT] = strtol (tmp, 0, 0);

	if (init_oid_info () < 0)
		return -1;

	if (init_listen (PORT_IDX_STAT) < 0)
		return -1;



	if (keepalivelib_init (myAppName) < 0)
		return -1;

	if (init_mysql () < 0)
		return -1;

	memset (&hold_list, 0, sizeof (HoldFList)*(FILE_NUM_5MIN+FILE_NUM_HOUR));

	return 1;

} /* End of init () */
Esempio n. 7
0
//----------------------------------------------------------------------
//!\brief           le main !
//----------------------------------------------------------------------
int main(void) {  
  
	//***************************
	//* INITIALISATION
	//***************************
	printf("Installing signal handler...");
	(void) signal(SIGINT, sigfun);
	printf("done\n");

	openlog(log_name, LOG_CONS, LOG_USER);
	syslog(LOG_DEBUG, "***************************************************************");
	syslog(LOG_DEBUG, "Demarrage bypassPC.c, logiciel de gestion du bypass du puits canadien");
	printf("Pour les messages de DEBUG, voir syslog : \\var\\log\\user.log \n");

	//lecture de la date/heure courante
	t = time(NULL);
	// conversion en heure locale
	local = localtime(&t); 
	syslog(LOG_DEBUG, "Heure et date courante : %s", asctime(local));
	syslog(LOG_DEBUG, "Unixtime : %d", t);

	//***************************************************************************
	//* PROGRAMME PRINCIPAL 
	//***************************************************************************

	//initialisation BDD
	if(init_mysql() == 1) {
		// erreur de liaison avec la bdd
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	// Récupération des données de températures : Ext, Int et PC
	if(recup_temperatures() == 1){
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	// récupération des infos du jour dans la table planning
	if(recup_info_jour("calendrier") == 1) {
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	// on lit les infos du jour dans le résultat de la reqête (1 seule ligne)
	if(read_info_jour() == 1){
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	//Récupération du type de consigne : Hiver  / Ete / Auto et de la température de consigne
	// on récupére les infos de températures en fonction de la saison
	if(read_info_saison(inf_saison) == 1){
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	int consignebypass = calcul_consigne_bypass(inf_saison, fconsigne_temperature);
	
	// Préparation du message à envoyer
	make_message(consignebypass);
	
	// Copie du message dans la BDD
	if(envoie_msg_radio(msg_radio) == 1){
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}
	
	//avant de sortir, on log les données de la structure stDonnees pour la mise au pointeur
	if(log_donnees(consignebypass) == 1) {
		// erreur dans le log
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	//Fermeture de MySQL
	mysql_close(conn);

	syslog(LOG_DEBUG, "Exit normally");
	closelog();

	return 0;
}
Esempio n. 8
0
void downloader_init(upstreams *upstr_ptr, mqd_t msgq_id) {

	/* Initialise MySQL connection */
	MYSQL_RES *result;
	MYSQL_ROW row;
	int num_fields;

	if ((conn = init_mysql(conn)) == NULL) {
		mysql_close(conn);
		error_log(ERROR, "MySQL initialisation failed");
		exit(EXIT_FAILURE);
	}

	if (!connect_mysql(conn)) {
		mysql_close(conn);
		error_log(ERROR, "MySQL connection failed");
		exit(EXIT_FAILURE);
	}

	int n;
	const config_setting_t *upstr_setting;
	static int upstream_count;

	upstr_setting = config_lookup(&cfg, "upstreams");
	upstream_count = config_setting_length(upstr_setting);

	error_log(ERROR, "Connected to MySQL.");
	struct mq_attr msgq_attr;
	int fe_id = cfg_get_int("fe_id");
	static char query[QUERY_MAX];
	unsigned int msgprio = 1;

	while (running) {
		/* Schedule upstreams */
		for (n = 0; n < upstream_count; n++) {
			if (!upstr_ptr[n].alive
					&& (time(NULL) - upstr_ptr[n].deadtime)
							> cfg_get_int("upstream_dead_timeout")) {
				error_log(DEBUG,
						"Making %s live again, time of dead: %d, now: %d",
						upstr_ptr[n].upstream, upstr_ptr[n].deadtime,
						time(NULL));
				upstr_ptr[n].alive = 1;
			}
			error_log(DEBUG, "Upstream: %s, active: %d", upstr_ptr[n].upstream,
					upstr_ptr[n].alive);
		}
		/* Get latest data */
		mq_getattr(msgq_id, &msgq_attr);
		if (!msgq_attr.mq_curmsgs) {
			if (cfg_get_int("dmode") == 2) {
				/* Query for robin mode*/
				sprintf(query,
						"SELECT filename, size from scoreboard WHERE id NOT "
								"IN(SELECT id from cached where fe_id=%d) AND count >=%d "
								"order by count DESC, last_modified DESC, size limit %d",
						fe_id, cfg_get_int("cache_req_count"),
						cfg_get_int("workers"));
			} else {
				/* Query for shard mode*/
				sprintf(query,
						"SELECT filename, size from scoreboard WHERE id NOT "
								"IN(SELECT id from cached where fe_id=%d) AND count >=%d "
								"AND fe_id=%d "
								"order by count DESC, last_modified DESC, size limit %d",
						fe_id, cfg_get_int("cache_req_count"), fe_id,
						cfg_get_int("workers"));
			}

			query_mysql(conn, query);
			result = mysql_store_result(conn);
			num_fields = mysql_num_fields(result);

			while ((row = mysql_fetch_row(result))) {
				if (row[0] && row[1]) {
					if (check_file_exists(row[0], atoi(row[1])) != 0) {
						continue;
					}
					mq_send(msgq_id, row[0], strlen(row[0]) + 1, msgprio);
				}
			}
			mysql_free_result(result);
		}
		sleep(5);
	}
	error_log(ERROR, "Exiting");
}
Esempio n. 9
0
//***********************************************
//----------------------------------------------------------------------
//!\brief		le main !
//!\input		Année pour laquelle il faut créer le planning; si NULL alors on prend l'année courante
//----------------------------------------------------------------------
//***********************************************
int main(int argc, char *argv[]) {  
  
	// Rappel
	printf("Arg : Annee pour laquelle il faut creer le planning\n Exemple : \n $ ./planning 2020\n");

	//***************************
	//* INITIALISATION
	//***************************
	printf("Installing signal handler...");
	(void) signal(SIGINT, sigfun);
	printf("done\n");


	//initialisation BDD
	if(init_mysql() == 1) {
	// erreur de liaison avec la bdd
	// prévoir un msg de log vers un fichier de log
	exit(1);
	}
	
	//***************************************************************************
	//* PROGRAMME PRINCIPAL 
	//***************************************************************************

	//lecture de la date/heure courante
	// t = nb de secondes depuis le 1er janvier 1970
	t = time(NULL);  
	// conversion en heure locale
	local = localtime(&t); 
	printf("Heure et date courante : %s\n", asctime(local));

	// si l'utilisateur n'a pas passée l'annee en argument
	if(argc != 2) {
		// on détermine l'année en cours
		stJourTraite.annee_planning = local->tm_year + 1900;
		printf("\n Pas d'argument, on prend l'année  en cours : %d", stJourTraite.annee_planning);
	}
	else{
		//sinon on prend l'annee passe en arguments
		stJourTraite.annee_planning = atoi(argv[1]);
		printf("on prend l'aneee  en argument : %d", stJourTraite.annee_planning);
	}
	
	
	//on commence par vider la table , l'année précédent étant passé, place à l'aveniiiiiiiiiiir
	// requete de la mort qui vide la une table : TRUNCATE TABLE `calendrier_30min`
	if(vider_table_jour() == 1) {
	// erreur sur la recuperation des messages
	// prévoir un msg de log vers un fichier de log
	exit(1);
	}

	//on calcule le nombre de jour pour l'année à venir
	if(calcul_nb_jour(stJourTraite.annee_planning) == 1) {
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	//Création du planning vierge
	if(planning_vierge(stJourTraite.annee_planning) == 1) {
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}
	
	//On affecte a chaque jour du calendrier les consignes de chauffe pour chaque tranche horaire
	if(affectation_jour_planning() == 1) {
		// erreur sur la recuperation des messages
		// prévoir un msg de log vers un fichier de log
		exit(1);
	}

	// fermeture de MySQL
	mysql_close(conn);

	printf("\nEXIT \n\n");

	//exit(0);
}
Esempio n. 10
0
int main(void) {

    int i;
    int ifd;
    int len;
    int client_sock;
    struct online_user *user;
    Client client;
    struct sockaddr_in client_name;
    int client_name_len = sizeof(client_name);
#define MAX_BUFSIZE	0x100000
    char buf[MAX_BUFSIZE];
    struct format *package = (struct format *)buf;

    tcp_server_sock = tcp_startup(SERVER_TCP_PORT);

    init_mysql();
    register_ctrl_c();

    kdpfd = epoll_create(MAXEPOLLSIZE);

    /* 设置要监听的事件。EPOLLIN 表示可读,EPOLLET则指定电平触发 */
    ev.events = EPOLLIN;
    ev.data.fd = tcp_server_sock;

    if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, tcp_server_sock, &ev) < 0)
        /* 把 tcp sock 加入监听集合,以便接收连接请求 */
        error_die("tcp epoll_ctl\n");

    /* 记录监听的文件数,同时他也是 epoll_wait 的第三个参数。
       因为内核需要知道 events 数组的有效数据有多长 */
    curfds = 1;

    for (;;) {

        memset(buf,0,sizeof(buf));
        printf("waiting...\n");

        /* 等待有事件发生。该函数的返回值存放在 nfds 和 events 内 */
        nfds = epoll_wait(kdpfd, events, curfds, -1);

        if (nfds < 0)
            error_die("epoll_wait");

        for (i = 0; i < nfds; i++) {

            ifd = events[i].data.fd;

            if (ifd == tcp_server_sock) {
                //新的 TCP 连接请求到来

                if (!(events[i].events & EPOLLIN))
                    error_die("failed to event is not EPOLLIN\n");

                client_sock = accept(tcp_server_sock,(struct sockaddr *)&client_name,&client_name_len);
                setnonblocking(client_sock);

                ev.events  = EPOLLIN;
                ev.data.fd = client_sock;
                if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, client_sock, &ev) < 0)
                    error_die("epoll_ctl");

                curfds++;

                client = alloc_client(client_sock);
                add_client(client);

            } else if ((events[i].events & EPOLLIN)) {
                /* 客户端有数据发来(POLLIN)或者发生 POLLHUP/POLLERR(这两个事件系统会自动监听) */

                client = find_client(ifd);

                if (client != NULL && client->handler != NULL) {
                    //已经有了处理函数,直接调用这个函数来处理
                    client->handler(ifd,client->private);
                } else {
                    //默认的处理方法

                    //读入数据包头部。
                    len = read(ifd,package,(sizeof(struct format)-sizeof(package->data)));

                    if (len <= 0) {
                        //对方断线。
                        close_connect(ifd);
                        continue;
                    }

                    if (package->length >= MAX_BUFSIZE || package->length <= 0) {

                        while(read(ifd,package->data,4) > 0);
                        continue;
                    }

                    if ((len = read(ifd,package->data,package->length) <= 0)) {
                        //读入数据包内容

                        close_connect(ifd);
                        continue;
                    }

                    // 处理数据
                    if (handle(ifd,package) == NEED_WRITE) {

                        ev.events = EPOLLOUT;
                        ev.data.fd = ifd;
                        epoll_ctl(kdpfd,EPOLL_CTL_MOD,ifd,&ev);
                    }
                }

            } else if(events[i].events & EPOLLOUT) {
Esempio n. 11
0
int main(int argc, char *argv[]) {

    //dichiarazioni variabili usate
	int i;
	char *param;
	//char valore_out[30];
	char query[MAX_LENGTH];
	riga_mysql row;						//rappresenta una riga del risultato di una query
	int serre_allocate=0;				//flag, indica se il proprietario ha delle serre ad esso associato.
										//In caso contrario � possibile rimuovere il proprietario
	char cf[17];		//codice fiscale del proprietario da cancellare
	
	
	printf("Content-type:text/html\n\n\n");                   //definizione del content-type
	//tag HTML
    printf("<html>\n");
	printf("<body>\n");
	printf("<h1>Eliminazione Proprietario di una serra</h1>");
	
	param = init_param();                                     //inizializzo parametri POST

	//connessione al database
	if (init_mysql() != 0) {                                  //controllo sulla corretta conessione al database
		param = del_param(param);
		fatal_error("Impossibile connettersi al database!");
	}
	
	if (param == NULL) {                                      //nessun parametro - visualizza il form per la cancellazione

		//esecuzione  select
		query[0] = '\0';                                      //inizializzazoine  stringa per la query
		strcat(query, "SELECT cognome, nome, cf FROM proprietario;");    //concatenazione  stringa
 
		//esecuzione query SQL
		if (select_start_mysql(query) != 0) {                 //controllo sull'esito dell'esecuzione della query SQL
			close_mysql();
			fatal_error("Impossibile comunicare con il database\n");
		}
		
		//FORM HTML
        printf("<form name=\"del_proprietario\" action=\"delproprietario\" method=\"post\">");
		printf("<select name=\"cfproprietario\">");
		
		while ((row = select_getrow_mysql()) != NULL) {       //acquisizione degli elementi per la stampa
			//row[0]=cognome, row[1]=nome, row[2]=cf
			printf("<option value=\"%s\">%s %s - %s</option>", row[2], row[0], row[1], row[2]);
		}
		
		//fine select HTML
        printf("</select>");
		printf("&nbsp;<input type=\"submit\" name=\"conferma\" value=\"Elimina\">");
		printf("</form>");
		
		select_stop_mysql();                                 //rilascio  memoria occupata per la select
	}
	else {                                                   //passato come parametro il codice fiscale del proprietario da cancellare
		if (find_n_param(param, "cfproprietario", cf, 17) == 1) { //controllo sull' estrazione del parametro "cfproprietario"
			param = del_param(param);
			print_menu();
			fatal_error("Non ci sono proprietari da cancellare dal database<br>");
		}
		
		
		//cancellazione
		query[0] = '\0';                                      //costruzione della variabile "query" che verr� usata per la select SQL
		strcat(query, "SELECT cf_proprietario, nome FROM serra WHERE cf_proprietario='");
		strcat(query, cf);
		strcat(query, "';");
		
		if (select_start_mysql(query) != 0) {                 //controllo sull'esito dell'esecuzione della select SQL
			close_mysql();
			param = del_param(param);
			fatal_error("Impossibile comunicare con il database\n");
		}
		
		while ((row = select_getrow_mysql()) != NULL) {        //ciclo per controllare se ad un proprietario � associata almeno una serra
			if (serre_allocate == 0) { //Esegue questo codice solo alla prima serra trovata nel database
				print_menu();
				printf("<p>Per questo proprietario sono allocate le seguenti serre:<br>");
				serre_allocate = 1;
			}
			printf("-> %s<br>", row[1]); //stampa il nome delle serre associate al proprietario
		}
		
		if (serre_allocate == 1) {
			fatal_error("Bisogna cancellare prima le serre elencate!<br>");
		}

		
		select_stop_mysql();                                    //rilascio memoria occupata per la select
		
		
		//preparazione  query SQL
		query[0] = '\0';                                        //costruzione della variabile "query" che verr� usata per la delete SQL
		strcat(query, "DELETE FROM proprietario WHERE cf='");
		strcat(query, cf);
		strcat(query, "';");
		
		//esecuzione query SQL
		if (insert_mysql(query) != 0) {                         //controllo sull'esito dell'esecuzione della insert SQL
			close_mysql();
			param = del_param(param);
			fatal_error("Impossibile cancellare dal database<br><a href=\"delproprietario\">Torna indietro</a><br>");
		}
		
		printf("Proprietario cancellato correttamente!<br>");
		print_menu();
		
	}
		
	param = del_param(param);                                   //eliminazione  parametri

	close_mysql();                                              //chiusura connessione

    //tag HTML
	printf("</body>\n");
	printf("</html>\n\n");

}