transmit_dialog.cpp

完整的RTP RTSP代码库

/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *		Dave Mackie		[e-mail]
 *		Bill May 		[e-mail]
 */

#define __STDC_LIMIT_MACROS
#include "mp4live.h"
#include "mp4live_gui.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include "rtp_transmitter.h"
#include "support.h"

static CMediaStream *media_stream;
static enum { 
  DO_AUDIO, 
  DO_VIDEO, 
  DO_TEXT
} addr_type = DO_AUDIO;

#ifdef HAVE_SRTP
static bool ValidateKeySalt (const char *value, bool dokey)
{
  uint max_ix = dokey ? 32 : 28;
  uint ix;

  for (ix = 0; ix < max_ix; ix++) {
    if (!isxdigit(value[ix])) {
      return false;
    }
  }
  return value[ix] == '\0';
}
#endif

static bool ValidatePort(GtkWidget* entry, in_port_t *port)
{
  int value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(entry));

	if (value < 1024 || value > 65534 || (value & 1)) {
		ShowMessage("Transmission Port Number",
			"Please enter an even number between 1024 and 65534");
		// TBD gtk_widget_grab_focus(widget);
		return false;
	}
	if (port) {
		*port = value;
	}
	return true;
}

static bool ValidateAddress (GtkWidget* widget)
{
	const char* address = gtk_entry_get_text(GTK_ENTRY(widget));

	struct in_addr in;
	if (inet_pton(AF_INET, address, &in) > 0) {
		return true;
	}

	struct in6_addr in6;
	if (inet_pton(AF_INET6, address, &in6) > 0) {
		return true;
	}

	// Might have a DNS address...
	if (gethostbyname(address) != NULL) {
		return true;
	}

	ShowMessage("Transmission Address", "Invalid address entered");
	return false;
}

#ifdef HAVE_SRTP
static void
on_SRTPEnableButton_toggled            (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  GtkWidget *dialog = GTK_WIDGET(user_data);
  bool enabled  = gtk_toggle_button_get_active(togglebutton);
  GtkWidget *temp = lookup_widget(GTK_WIDGET(dialog), "SrtpAuthType");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "SrtpEncType");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "EnableRtpEncCheckButton");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "EnableRtpAuthCheckButton");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "EnableRtpAuthCheckButton");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "EnableRtcpEncCheckButton");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "SpecifyKeySaltCheckButton");
  gtk_widget_set_sensitive(temp, enabled);
  if (enabled) {
    enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(temp));
  }
  temp = lookup_widget(GTK_WIDGET(dialog), "SrtpKeyValue");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "SrtpSaltValue");
  gtk_widget_set_sensitive(temp, enabled);
  
}


static void
on_SpecifyKeySaltCheckButton_toggled   (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  GtkWidget *dialog = GTK_WIDGET(user_data);
  bool enabled  = gtk_toggle_button_get_active(togglebutton);
  GtkWidget *temp = lookup_widget(GTK_WIDGET(dialog), "SrtpKeyValue");
  gtk_widget_set_sensitive(temp, enabled);
  temp = lookup_widget(GTK_WIDGET(dialog), "SrtpSaltValue");
  gtk_widget_set_sensitive(temp, enabled);
}
#endif

static void
on_IpAddrDialog_response               (GtkDialog       *dialog,
                                        gint             response_id,
                                        gpointer         user_data)
{
  config_index_t fixed, addr, port;
  config_index_t use_srtp, enc_algo, auth_algo, srtp_fixed_keys, srtp_key, srtp_salt;
  config_index_t rtp_enc, rtp_auth, rtcp_enc;
  switch (addr_type) {
  case DO_AUDIO:
    fixed = STREAM_AUDIO_ADDR_FIXED;
    addr = STREAM_AUDIO_DEST_ADDR;
    port = STREAM_AUDIO_DEST_PORT;
    use_srtp = STREAM_AUDIO_USE_SRTP;
    enc_algo = STREAM_AUDIO_SRTP_ENC_ALGO;
    auth_algo = STREAM_AUDIO_SRTP_AUTH_ALGO;
    srtp_fixed_keys = STREAM_AUDIO_SRTP_FIXED_KEYS;
    srtp_key = STREAM_AUDIO_SRTP_KEY;
    srtp_salt = STREAM_AUDIO_SRTP_SALT;
    rtp_enc = STREAM_AUDIO_SRTP_RTP_ENC;
    rtp_auth = STREAM_AUDIO_SRTP_RTP_AUTH;
    rtcp_enc = STREAM_AUDIO_SRTP_RTCP_ENC;
    break;
  case DO_VIDEO:
    fixed = STREAM_VIDEO_ADDR_FIXED;
    addr = STREAM_VIDEO_DEST_ADDR;
    port = STREAM_VIDEO_DEST_PORT;
    use_srtp = STREAM_VIDEO_USE_SRTP;
    enc_algo = STREAM_VIDEO_SRTP_ENC_ALGO;
    auth_algo = STREAM_VIDEO_SRTP_AUTH_ALGO;
    srtp_fixed_keys = STREAM_VIDEO_SRTP_FIXED_KEYS;
    srtp_key = STREAM_VIDEO_SRTP_KEY;
    srtp_salt = STREAM_VIDEO_SRTP_SALT;
    rtp_enc = STREAM_VIDEO_SRTP_RTP_ENC;
    rtp_auth = STREAM_VIDEO_SRTP_RTP_AUTH;
    rtcp_enc = STREAM_VIDEO_SRTP_RTCP_ENC;
    break;
  case DO_TEXT:
  default:
    fixed = STREAM_TEXT_ADDR_FIXED;
    addr = STREAM_TEXT_DEST_ADDR;
    port = STREAM_TEXT_DEST_PORT;
    use_srtp = STREAM_TEXT_USE_SRTP;
    enc_algo = STREAM_TEXT_SRTP_ENC_ALGO;
    auth_algo = STREAM_TEXT_SRTP_AUTH_ALGO;
    srtp_fixed_keys = STREAM_TEXT_SRTP_FIXED_KEYS;
    srtp_key = STREAM_TEXT_SRTP_KEY;
    srtp_salt = STREAM_TEXT_SRTP_SALT;
    rtp_enc = STREAM_TEXT_SRTP_RTP_ENC;
    rtp_auth = STREAM_TEXT_SRTP_RTP_AUTH;
    rtcp_enc = STREAM_TEXT_SRTP_RTCP_ENC;
    break;
  }
      
  if (response_id == GTK_RESPONSE_OK) {
#ifdef HAVE_SRTP
    GtkWidget *temp;
    bool have_srtp;
    temp = lookup_widget(GTK_WIDGET(dialog), "SRTPEnableButton");
    have_srtp = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(temp));
    if (have_srtp) {
      temp = lookup_widget(GTK_WIDGET(dialog), "SpecifyKeySaltCheckButton");
      if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(temp))) {
	temp = lookup_widget(GTK_WIDGET(dialog), "SrtpSaltValue");
	if (ValidateKeySalt(gtk_entry_get_text(GTK_ENTRY(temp)), false) == false) {
	  ShowMessage("Transmission Address", "Invalid salt entered");
	  return;
	}
	temp = lookup_widget(GTK_WIDGET(dialog), "SrtpKeyValue");
	if (ValidateKeySalt(gtk_entry_get_text(GTK_ENTRY(temp)), true) == false) {
	  ShowMessage("Transmission Address", "Invalid key entered");
	  return;
	}
      }
    }
#endif
      
    GtkWidget *fixedw = lookup_widget(GTK_WIDGET(dialog), "FixedAddrButton");
    
    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fixedw))) {
      in_port_t readport;
      GtkWidget *ipaddr;
      ipaddr = lookup_widget(GTK_WIDGET(dialog), "IpAddr");
      if (ValidateAddress(ipaddr) == false)
	return;
      if (ValidatePort(lookup_widget(GTK_WIDGET(dialog), 
				     "IpPort"), &readport) == false) 
	return;
      media_stream->SetBoolValue(fixed, true);
      media_stream->SetStringValue(addr, gtk_entry_get_text(GTK_ENTRY(ipaddr)));
      media_stream->SetIntegerValue(port, readport);
    } else {
      media_stream->SetBoolValue(fixed, false);
    }
#ifdef HAVE_SRTP
    if (have_srtp) {
      media_stream->SetBoolValue(use_srtp, true);
      temp = lookup_widget(GTK_WIDGET(dialog), "SrtpEncType");
      media_stream->SetIntegerValue(enc_algo, 
				    gtk_combo_box_get_active(GTK_COMBO_BOX(temp)));
      temp = lookup_widget(GTK_WIDGET(dialog), "SrtpAuthType");
      media_stream->SetIntegerValue(auth_algo, 
				    gtk_combo_box_get_active(GTK_COMBO_BOX(temp)));
      temp = lookup_widget(GTK_WIDGET(dialog), "SpecifyKeySaltCheckButton");
      bool specify_key = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(temp));
      media_stream->SetBoolValue(srtp_fixed_keys, specify_key);
      if (specify_key) {
	temp = lookup_widget(GTK_WIDGET(dialog), "SrtpKeyValue");
	media_stream->SetStringValue(srtp_key, gtk_entry_get_text(GTK_ENTRY(temp)));
	temp = lookup_widget(GTK_WIDGET(dialog), "SrtpSaltValue");
	media_stream->SetStringValue(srtp_salt, gtk_entry_get_text(GTK_ENTRY(temp)));
      }
      temp = lookup_widget(GTK_WIDGET(dialog), "EnableRtpEncCheckButton");
      media_stream->SetBoolValue(rtp_enc, 
				 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(temp)));
      temp = lookup_widget(GTK_WIDGET(dialog), "EnableRtpAuthCheckButton");
      media_stream->SetBoolValue(rtp_auth, 
				 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(temp)));
      temp = lookup_widget(GTK_WIDGET(dialog), "EnableRtcpEncCheckButton");
      media_stream->SetBoolValue(rtcp_enc, 
				 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(temp)));
    } else {
      media_stream->SetBoolValue(use_srtp, false);
    }
#endif
    AVFlow->ValidateAndUpdateStreams();
    RefreshCurrentStream();
  }
  gtk_widget_destroy(GTK_WIDGET(dialog));
}


static void
on_FixedAddrButton_toggled             (GtkToggleButton *togglebutton,
                                        gpointer         user_data)
{
  GtkWidget *dialog = GTK_WIDGET(user_data);
  GtkWidget *ipaddr, *ipport;
  ipaddr = lookup_widget(dialog, "IpAddr");
  ipport = lookup_widget(dialog, "IpPort");
  debug_message("fixed toggled %p", togglebutton);
  bool test = gtk_toggle_button_get_active(togglebutton);

  gtk_widget_set_sensitive(ipaddr, test);
  gtk_widget_set_sensitive(ipport, test);
}

void create_IpAddrDialog (CMediaStream *ms, 
			  bool do_audio, 
			  bool do_video, 
			  bool do_text)
{
  GtkWidget *IpAddrDialog;
  GtkWidget *dialog_vbox6;
  GtkWidget *vbox35;
  GtkWidget *IpAddrDialogLabel;
  GtkWidget *table4;
  GtkWidget *GenerateAddrButton;
  GSList *GenerateAddrButton_group = NULL;
  GtkWidget *FixedAddrButton;
  GtkWidget *GenerateAddrLable;
  GtkWidget *hbox74;
  GtkWidget *IpAddr;
  GtkWidget *label149;
  GtkObject *IpPort_adj;
  GtkWidget *IpPort;
#ifdef HAVE_SRTP
  GtkWidget *hseparator1;
  GtkWidget *vbox49;
  GtkWidget *alignment37;
  GtkWidget *SRTPEnableButton;
  GtkWidget *SrtpParametersTable;
  GtkWidget *label215;
  GtkWidget *SrtpAuthType;
  GtkWidget *label216;
  GtkWidget *SpecifyKeySaltCheckButton;
  GtkWidget *label217;
  GtkWidget *SrtpKeyValue;
  GtkWidget *label218;
  GtkWidget *SrtpSaltValue;
  GtkWidget *label220;
  GtkWidget *label221;
  GtkWidget *EnableRtpEncCheckButton;
  GtkWidget *EnableRtpAuthCheckButton;
  GtkWidget *EnableRtcpEncCheckButton;
  GtkWidget *label222;
  GtkWidget *SrtpEncType;
  GtkWidget *label223;
#endif
  GtkWidget *dialog_action_area5;
  GtkWidget *cancelbutton5;
  GtkWidget *okbutton5;
  GtkTooltips *tooltips;
  media_stream = ms;


  tooltips = gtk_tooltips_new();

  IpAddrDialog = gtk_dialog_new();
  gtk_window_set_title(GTK_WINDOW(IpAddrDialog), _("Transmit Address and Parameters"));
  gtk_window_set_modal(GTK_WINDOW(IpAddrDialog), TRUE);
  gtk_window_set_resizable(GTK_WINDOW(IpAddrDialog), FALSE);
  gtk_window_set_transient_for(GTK_WINDOW(IpAddrDialog), 
			       GTK_WINDOW(MainWindow));

  dialog_vbox6 = GTK_DIALOG(IpAddrDialog)->vbox;
  gtk_widget_show(dialog_vbox6);

  vbox35 = gtk_vbox_new(FALSE, 0);
  gtk_widget_show(vbox35);
  gtk_box_pack_start(GTK_BOX(dialog_vbox6), vbox35, TRUE, TRUE, 0);

  IpAddrDialogLabel = gtk_label_new(_("label147"));
  gtk_widget_show(IpAddrDialogLabel);
  gtk_box_pack_start(GTK_BOX(vbox35), IpAddrDialogLabel, FALSE, FALSE, 0);

  table4 = gtk_table_new(2, 2, FALSE);
  gtk_widget_show(table4);
  gtk_box_pack_start(GTK_BOX(vbox35), table4, TRUE, TRUE, 0);