sms.c

这个项目里有两个关于收、发GSM 手机短信的C语言程序

    char *value;

    argc = sms_param->Pv->NbParams;
    /* update structure */
    sms_param->argc = argc;
    sms_param->argv = g_new(gchar *, argc);;
    /* get all fields */
    for (i = 0; i < argc; i++)
    {
    	value = (char *)NULL;
	if (g_strcasecmp(sms_param->Pv->Params[i].Name, "Message") == 0)
	{
	    gchar **valuearray;
	    gchar *valuetmp;
	    /* change newline to space (use glib string arrays) */
	    GtkEditable *edit = GTK_EDITABLE(sms_param->Pv->Params[i].Widget);
	    valuetmp = gtk_editable_get_chars(edit, 0, -1);
#ifdef ERASE
	    gtk_editable_delete_text(edit,0,-1);
#endif
	    valuearray = g_strsplit(valuetmp,"\n",sms_param->Pv->Params[i].Size);
	    value = g_strjoinv(" ",valuearray);
	    sms_param->argv[i] = g_strdup_printf("%s", value);
	    g_strfreev(valuearray);
	    g_free(valuetmp);
	    g_free(value);
	}
	else
	{
	    value = gtk_entry_get_text(GTK_ENTRY(sms_param->Pv->Params[i].Widget));
#ifdef ERASE
	    gtk_editable_delete_text(GTK_EDITABLE(sms_param->Pv->Params[i].Widget),0,-1);
#endif
	    if (KeepPass && g_strncasecmp(sms_param->Pv->Params[i].Name, "Password",10) == 0)
	    {
		/* save password in preference file */
		gchar *config_file;
		gchar *path;
		gchar *temp;

		config_file=gnome_util_prepend_user_home(".smssend/smssendrc");
		path = g_strdup_printf("=%s=/Passwords/%s",config_file,sms_param->Pv->Label);
		if (value && strlen(value))
		{
		    temp = g_strdup(value);
		    crypt_password(temp);
		    gnome_config_set_string(path,temp);
		    g_free(temp);
		}
		g_free(path);
		g_free(config_file);
		gnome_config_sync();
	    }
	    sms_param->argv[i] = g_strdup(value);
	    g_free(value);
	}
    }
}

/* -----------------------------------------------------------------------------------*/
/* temporary defines to eliminate appbar updating */
#define Gnome_appbar_set_status(a,b) 
/*
	GDK_THREADS_ENTER(); \
	gnome_appbar_set_status(a,b); \
	GDK_THREADS_LEAVE(); 
*/
#define Gnome_appbar_set_progress(a,b) 
/*
	GDK_THREADS_ENTER(); \
	gnome_appbar_set_progress(a,b); \
	GDK_THREADS_LEAVE();
*/

static void *DoSms(void *arg)
{
    /* thread to call smssend in a fork->exec */
    PcmdParam_t sms_param = (PcmdParam_t) arg;
    gchar  proxy[P_LENGTH+8] = "";
    gchar  pass[P_LENGTH*2+3] = "";
    gchar  debug[10] = "";
    gchar  timeout[5] = "";
    gchar  *headerfile = (gchar *)NULL;
    gchar  *args[16];
    static int   retval=0;
    gint fd1[2], fd2[2], fd3[2];
    int i,ret;

    sms_param->SmsId = -1;
    pthread_detach (pthread_self ());

    /* attach a 'ignore' signal handler to SIGCHLD to avoid zombies */
    signal(SIGCHLD,SIG_IGN);

    /* check smssend presence */
    args[0] = gnome_is_program_in_path (SMSEXECNAME);
    if (!args[0])
    {
	  g_printerr(_("SmsSend not found!\n"));
	  Gnome_appbar_set_status(GNOME_APPBAR(Appbar), _("SmsSend not found!"));
	  Gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 0.0);
    	  pthread_exit((void *)(-1));
          /* Not reached  */
          return ((void *)(-1));
    }

    /* do the pipe-stuff */
    if (pipe(fd1) <0 || pipe(fd2) <0 || pipe(fd3) <0) 
    {
    	  g_free(args[0]);
	  g_printerr(_("SmsSend: pipe error!\n"));
	  Gnome_appbar_set_status(GNOME_APPBAR(Appbar), _("SmsSend: pipe error!"));
	  Gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 0.0);
    	  pthread_exit((void *)(-1));
          /* Not reached  */
          return ((void *)(-1));
    }

    if (UseProxy)
    {
	  /* update proxy args */
	  g_snprintf(proxy, P_LENGTH+8, "-p%s:%d", ProxyHost, ProxyPort);
	  if (strlen(ProxyUser))
	  {
		g_snprintf(pass, P_LENGTH*2+3, "-u%s:%s", ProxyUser, ProxyPass);
	  }
    }

    /* fork a smssend process */
    for (ret=Retries;ret > 0; ret--) { /* RETRIES loop */
    sms_param->SmsId = fork();
    if (sms_param->SmsId == 0)
    {
	  /* child process */
	  int argc=0, lastarg;

	  close(fd1[1]);
	  close(fd2[0]);
          close(fd3[0]);

          /* reroute stdin from child */
          if (fd1[0] != STDIN_FILENO) {
              if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO) {
                  g_error(_("SmsSend: dup2 error on stdin\n"));
              }
              close(fd1[0]);
          }
          /* reroute stdout from child */
          if (fd2[1] != STDOUT_FILENO) {
              if (dup2(fd2[1], STDOUT_FILENO) != STDOUT_FILENO) {
                  g_error(_("SmsSend: dup2 error on stdout\n"));
              }
              close(fd2[1]);
          }
          /* reroute stderr from child */
          if (fd3[1] != STDERR_FILENO) {
              if (dup2(fd3[1], STDERR_FILENO) != STDERR_FILENO) {
                  g_error(_("SmsSend: dup2 error on stderr\n"));
              }
              close(fd3[1]);
          }
	  Gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 0.25);

	  /* create args array */
	  if (sms_param->Pv)
	  {
              args[1] = sms_param->Pv->Filename;
	      if (sms_param->argc <= 0)
              	CreateArgv(sms_param);
              argc = sms_param->argc;
    	      for (i=0;i<argc;i++)
		  args[2 + i] = sms_param->argv[i];

	  }
	  else if (sms_param->Help)
	  {
	      args[1] = (char *)arg_help;
	  }
	  else if (sms_param->Update)
	  {
	      args[1] = (char *)arg_update;
	  }

          lastarg = argc + 2;

	  if ((UseProxy)||(DebugLevel)||(TimeOut)||(HeaderFile))
		/* don't forget the '--' ! */
		args[lastarg++] = (char *)arg_minus;
	  if (UseProxy)
	  {
		args[lastarg++] = proxy;
		args[lastarg++] = pass;
	  }
	  if (DebugLevel)
	  {
	  	g_snprintf(debug, 10, "-d%d", DebugLevel);
		args[lastarg++] = debug;
	  }
	  if (TimeOut)
	  {
	  	g_snprintf(timeout, 5, "-t%d", TimeOut);
		args[lastarg++] = timeout;
	  }
	  if (HeaderFile)
	  {
		headerfile=g_strdup_printf("-h%s",HeaderFile);
		args[lastarg++] = headerfile;
	  }
	  args[lastarg] = NULL;
	  Gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 0.50);
	  /* call smssend */
	  execvp(SMSEXECNAME, args);
          /* if exec() returns, there is something wrong */
	  g_printerr(_("SmsSend exec failed!\n"));
	  Gnome_appbar_set_status(GNOME_APPBAR(Appbar), _("SmsSend exec failed!"));
	  /* free all allocated strings */
	  if (headerfile)
	      g_free(headerfile);
	  for (i = 0; i < argc; i++)
		g_free(args[2 + i]);
	  g_free(sms_param->argv);
	  Gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 0.0);
	  retval = -2;
          /* exit child. note the use of _exit() instead of exit() */
	  _exit(-2);
    	  /* Not reached  */
    }

    /* parent: wait for child process to end before exiting thread */
    if (sms_param->SmsId > 0)
    {
	  int maxsleep;
          /* set output to nonblocking - otherwise our callback would block */
          fcntl(fd2[0], F_SETFL, O_NONBLOCK);
          fcntl(fd3[0], F_SETFL, O_NONBLOCK);

          /* catch output of child */
	  sms_param->Callback = gdk_input_add(fd2[0], GDK_INPUT_READ,
                                  (GdkInputFunction) smssend_stdout,
                                  (gpointer)arg);
	  sms_param->Callback2 = gdk_input_add(fd3[0], GDK_INPUT_READ,
                                  (GdkInputFunction) smssend_stderr, 
                                  (gpointer)arg);
	  /* wait, doing nothing with a timeout */
	  i = 0;
          if (TimeOut) maxsleep = TimeOut * 2;
	  else         maxsleep = DEF_TIMEOUT * 2;
          while ((sms_param->Done == NOT_DONE) && (i++ < maxsleep))
	  {
		usleep(HALF_SECOND);
#ifdef DEBUG
fprintf(stderr,".");
#endif
	  }
	  if (sms_param->Done == NOT_DONE)
	  {
		/* 'twas a time out ! */
		gtk_input_remove(sms_param->Callback);
		gtk_input_remove(sms_param->Callback2);
		kill(sms_param->SmsId,SIGTERM);
#ifdef DEBUG
fprintf(stderr,"-");
#endif
	  }
	  close(fd2[0]);
	  close(fd3[0]);
	  close(fd1[1]);
          retval = sms_param->Done;
	  Gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 1.0);
    }
    else
    {
	  g_printerr(_("SmsSend fork failed!\n"));
	  Gnome_appbar_set_status(GNOME_APPBAR(Appbar), _("SmsSend fork failed!"));
	  Gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 0.0);
	  retval = -3;
    }
    if (retval == 0)
	    break;
    else
	  Gnome_appbar_set_status(GNOME_APPBAR(Appbar), _("SmsSend fork retried!"));
    /* End RETRIES loop */
    }

    /* free allocated memories */
    g_free(args[0]);
    if (headerfile)
        g_free(headerfile);
    if (sms_param->argc)
    {
    	for (i = 0; i < sms_param->argc; i++)
	    g_free(sms_param->argv[i]);
    	g_free(sms_param->argv);
    }
    g_free(sms_param);
#ifdef DEBUG
fprintf(stderr,"Exit thread\n");
#endif
    pthread_exit((void *)retval);
    /* Not reached  */
    return ((void *)retval);
}
#undef Gnome_appbar_set_status
#undef Gnome_appbar_set_progress

/* -----------------------------------------------------------------------------------*/
void DelayedSms(gpointer data, gpointer user_data)
{
    /* thread stuff */
    pthread_t      thread_sms;
    int            thread_status;
    PcmdParam_t sms_param = (PcmdParam_t) data;

    thread_status = pthread_create(&thread_sms, NULL, DoSms, (void *)sms_param);
    if (thread_status < 0)
       g_printerr(_("Error creating delayed SmsSend thread!\n"));

}

/* -----------------------------------------------------------------------------------*/
void LaunchSms(PProvider_t Pv, gboolean Help, gboolean Update)
{
    /* allocate parameters struct */
    PcmdParam_t sms_param = g_new(cmdParam_t, 1);
    /* thread stuff */
    pthread_t      thread_sms;
    int            thread_status;

    sms_param->Pv        = Pv;
    sms_param->Help      = Help;
    sms_param->Update    = Update;
    sms_param->Callback  = 0;
    sms_param->Callback2 = 0;
    sms_param->Done      = NOT_DONE;
    sms_param->argc      = 0;
    sms_param->argv      = NULL;

    gnome_appbar_set_status(GNOME_APPBAR(Appbar), "SmsSend ...");
    gnome_appbar_set_progress(GNOME_APPBAR(Appbar), 0.0);

    thread_status = pthread_create(&thread_sms, NULL, DoSms, (void *)sms_param);
    if (thread_status < 0)
       g_printerr(_("Error creating SmsSend thread!\n"));
}