X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=apps%2Fsilcd%2Fpacket_send.c;h=8062551faa4d9393e83a1745095ec68ee961391e;hb=386c883d8774999c6e74d7c6c37e52e4163a4cb1;hp=b18da81a77c42749f3b19bb015d5fcd5ecd9dd8e;hpb=62cb7719f63ea3d3b7620533f5797dc7546b215a;p=silc.git

diff --git a/apps/silcd/packet_send.c b/apps/silcd/packet_send.c
index b18da81a..8062551f 100644
--- a/apps/silcd/packet_send.c
+++ b/apps/silcd/packet_send.c
@@ -386,6 +386,78 @@ void silc_server_packet_route(SilcServer server,
   silc_server_packet_send_real(server, sock, TRUE);
 }
 
+/* This routine can be used to send a packet to table of clients provided
+   in `clients'. If `route' is FALSE the packet is routed only to local
+   clients (for server locally connected, and for router local cell). */
+
+void silc_server_packet_send_clients(SilcServer server,
+				     SilcClientEntry *clients,
+				     uint32 clients_count,
+				     SilcPacketType type, 
+				     SilcPacketFlags flags,
+				     bool route,
+				     unsigned char *data, 
+				     uint32 data_len,
+				     bool force_send)
+{
+  SilcSocketConnection sock = NULL;
+  SilcClientEntry client = NULL;
+  SilcServerEntry *routed = NULL;
+  uint32 routed_count = 0;
+  bool gone = FALSE;
+  int i, k;
+
+  SILC_LOG_DEBUG(("Sending packet to list of clients"));
+
+  /* Send to all clients in table */
+  for (i = 0; i < clients_count; i++) {
+    client = clients[i];
+
+    /* If client has router set it is not locally connected client and
+       we will route the message to the router set in the client. Though,
+       send locally connected server in all cases. */
+    if (server->server_type == SILC_ROUTER && client->router && 
+	((!route && client->router->router == server->id_entry) || route)) {
+
+      /* Check if we have sent the packet to this route already */
+      for (k = 0; k < routed_count; k++)
+	if (routed[k] == client->router)
+	  break;
+      if (k < routed_count)
+	continue;
+
+      /* Route only once to router */
+      sock = (SilcSocketConnection)client->router->connection;
+      if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
+	if (gone)
+	  continue;
+	gone = TRUE;
+      }
+
+      /* Send the packet */
+      silc_server_packet_send_dest(server, sock, type, flags,
+				   client->router->id, SILC_ID_SERVER,
+				   data, data_len, force_send);
+
+      /* Mark this route routed already */
+      routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
+      routed[routed_count++] = client->router;
+      continue;
+    }
+
+    if (client->router)
+      continue;
+
+    /* Send to locally connected client */
+    sock = (SilcSocketConnection)client->connection;
+    silc_server_packet_send_dest(server, sock, type, flags,
+				 client->id, SILC_ID_CLIENT,
+				 data, data_len, force_send);
+  }
+
+  silc_free(routed);
+}
+
 /* Internal routine to actually create the channel packet and send it
    to network. This is common function in channel message sending. If
    `channel_message' is TRUE this encrypts the message as it is strictly
@@ -404,6 +476,10 @@ silc_server_packet_send_to_channel_real(SilcServer server,
 					bool force_send)
 {
   int block_len;
+
+  if (!sock)
+    return;
+
   packet->truelen = data_len + SILC_PACKET_HEADER_LEN + 
     packet->src_id_len + packet->dst_id_len;
 
@@ -453,7 +529,8 @@ silc_server_packet_send_to_channel_real(SilcServer server,
    If `route' is FALSE then the packet is sent only locally and will not
    be routed anywhere (for router locally means cell wide). If `sender'
    is provided then the packet is not sent to that connection since it
-   originally came from it. */
+   originally came from it. If `send_to_clients' is FALSE then the
+   packet is not sent clients, only servers. */
 
 void silc_server_packet_send_to_channel(SilcServer server,
 					SilcSocketConnection sender,
@@ -502,7 +579,7 @@ void silc_server_packet_send_to_channel(SilcServer server,
     idata = (SilcIDListData)router;
     
     if (sock != sender) {
-      SILC_LOG_DEBUG(("Sending channel message to router for routing"));
+      SILC_LOG_DEBUG(("Sending packet to router for routing"));
       
       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 					      idata->send_key, 
@@ -584,6 +661,7 @@ void silc_server_packet_send_to_channel(SilcServer server,
 					    force_send);
   }
 
+  silc_hash_table_list_reset(&htl);
   silc_free(routed);
   silc_free(packetdata.src_id);
   silc_free(packetdata.dst_id);
@@ -797,8 +875,7 @@ void silc_server_packet_relay_to_channel(SilcServer server,
 	/* If private key mode is not set then decrypt the packet
 	   and re-encrypt it */
 	if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
-	  unsigned char *tmp = silc_calloc(data_len, sizeof(*data));
-	  memcpy(tmp, data, data_len);
+	  unsigned char *tmp = silc_memdup(data, data_len);
 
 	  /* Decrypt the channel message (we don't check the MAC) */
 	  if (channel->channel_key &&
@@ -866,6 +943,7 @@ void silc_server_packet_relay_to_channel(SilcServer server,
 					    force_send);
   }
 
+  silc_hash_table_list_reset(&htl);
   silc_free(routed);
   silc_free(packetdata.src_id);
   silc_free(packetdata.dst_id);
@@ -904,6 +982,7 @@ void silc_server_packet_send_local_channel(SilcServer server,
 				   force_send);
     }
   }
+  silc_hash_table_list_reset(&htl);
 }
 
 /* Routine used to send (relay, route) private messages to some destination.
@@ -956,13 +1035,14 @@ void silc_server_send_private_message(SilcServer server,
 void silc_server_send_motd(SilcServer server,
 			   SilcSocketConnection sock)
 {
-  char *motd;
+  char *motd, *motd_file = NULL;
   uint32 motd_len;
 
-  if (server->config && server->config->motd && 
-      server->config->motd->motd_file) {
+  if (server->config)
+    motd_file = server->config->server_info->motd_file;
 
-    motd = silc_file_read(server->config->motd->motd_file, &motd_len);
+  if (motd_file) {
+    motd = silc_file_readfile(motd_file, &motd_len);
     if (!motd)
       return;
 
@@ -1132,7 +1212,8 @@ void silc_server_send_notify_cmode(SilcServer server,
 				   SilcChannelEntry channel,
 				   uint32 mode_mask,
 				   void *id, SilcIdType id_type,
-				   char *cipher, char *hmac)
+				   char *cipher, char *hmac,
+				   char *passphrase)
 {
   SilcBuffer idp;
   unsigned char mode[4];
@@ -1142,15 +1223,17 @@ void silc_server_send_notify_cmode(SilcServer server,
 
   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 			       SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
-			       4, idp->data, idp->len,
+			       5, idp->data, idp->len,
 			       mode, 4,
 			       cipher, cipher ? strlen(cipher) : 0,
-			       hmac, hmac ? strlen(hmac) : 0);
+			       hmac, hmac ? strlen(hmac) : 0,
+			       passphrase, passphrase ? 
+			       strlen(passphrase) : 0);
   silc_buffer_free(idp);
 }
 
 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
-   `target' client's mode on `channel'. The Notify packet is always
+   `target' client's mode on `channel'. The notify packet is always
    destined to the channel. */
 
 void silc_server_send_notify_cumode(SilcServer server,
@@ -1187,7 +1270,7 @@ void silc_server_send_notify_signoff(SilcServer server,
 				     SilcSocketConnection sock,
 				     bool broadcast,
 				     SilcClientID *client_id,
-				     char *message)
+				     const char *message)
 {
   SilcBuffer idp;
 
@@ -1199,7 +1282,7 @@ void silc_server_send_notify_signoff(SilcServer server,
   silc_buffer_free(idp);
 }
 
-/* Sends TOPIC_SET notify type. This tells that `client_id' changed
+/* Sends TOPIC_SET notify type. This tells that `id' changed
    the `channel's topic to `topic'. The Notify packet is always destined
    to the channel. This function is used to send the topic set notifies
    between routers. */
@@ -1208,17 +1291,18 @@ void silc_server_send_notify_topic_set(SilcServer server,
 				       SilcSocketConnection sock,
 				       bool broadcast,
 				       SilcChannelEntry channel,
-				       SilcClientID *client_id,
+				       void *id, SilcIdType id_type,
 				       char *topic)
 {
   SilcBuffer idp;
 
-  idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
-  silc_server_send_notify(server, sock, broadcast,
-			  SILC_NOTIFY_TYPE_TOPIC_SET,
-			  topic ? 2 : 1, 
-			  idp->data, idp->len, 
-			  topic, topic ? strlen(topic) : 0);
+  idp = silc_id_payload_encode(id, id_type);
+  silc_server_send_notify_dest(server, sock, broadcast,
+			       (void *)channel->id, SILC_ID_CHANNEL,
+			       SILC_NOTIFY_TYPE_TOPIC_SET,
+			       topic ? 2 : 1, 
+			       idp->data, idp->len, 
+			       topic, topic ? strlen(topic) : 0);
   silc_buffer_free(idp);
 }
 
@@ -1232,16 +1316,21 @@ void silc_server_send_notify_kicked(SilcServer server,
 				    bool broadcast,
 				    SilcChannelEntry channel,
 				    SilcClientID *client_id,
+				    SilcClientID *kicker,
 				    char *comment)
 {
-  SilcBuffer idp;
+  SilcBuffer idp1;
+  SilcBuffer idp2;
 
-  idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
+  idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
+  idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
-			       SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED,
-			       comment ? 2 : 1, idp->data, idp->len,
-			       comment, comment ? strlen(comment) : 0);
-  silc_buffer_free(idp);
+			       SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
+			       idp1->data, idp1->len,
+			       comment, comment ? strlen(comment) : 0,
+			       idp2->data, idp2->len);
+  silc_buffer_free(idp1);
+  silc_buffer_free(idp2);
 }
 
 /* Send KILLED notify type. This tells that the `client_id' client was
@@ -1369,7 +1458,7 @@ void silc_server_send_notify_dest(SilcServer server,
 void silc_server_send_notify_to_channel(SilcServer server,
 					SilcSocketConnection sender,
 					SilcChannelEntry channel,
-					unsigned char route_notify,
+					bool route_notify,
 					SilcNotifyType type,
 					uint32 argc, ...)
 {
@@ -1527,11 +1616,14 @@ void silc_server_send_notify_on_channels(SilcServer server,
 	sent_clients[sent_clients_count++] = c;
       }
     }
+    silc_hash_table_list_reset(&htl2);
   }
 
+  silc_hash_table_list_reset(&htl);
   silc_free(routed);
   silc_free(sent_clients);
   silc_free(packetdata.src_id);
+  silc_buffer_free(packet);
   va_end(ap);
 }
 
@@ -1567,9 +1659,8 @@ void silc_server_send_new_id(SilcServer server,
 }
 
 /* Send New Channel Payload to notify about newly created channel in the
-   SILC network. Normal server nevers sends this packet. Router uses this
-   to notify other routers in the network about new channel. This packet
-   is broadcasted. */
+   SILC network. Router uses this to notify other routers in the network 
+   about new channel. This packet is broadcasted by router. */
 
 void silc_server_send_new_channel(SilcServer server,
 				  SilcSocketConnection sock,
@@ -1599,7 +1690,8 @@ void silc_server_send_new_channel(SilcServer server,
 
   /* Send to backup routers if this is being broadcasted to primary
      router. */
-  if (server->router && server->router->connection &&
+  if (server->server_type == SILC_ROUTER &&
+      server->router && server->router->connection &&
       sock == server->router->connection && broadcast)
     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
 			    packet->data, packet->len, FALSE, TRUE);
@@ -1626,7 +1718,7 @@ void silc_server_send_channel_key(SilcServer server,
   unsigned char *chid;
   uint32 tmp_len;
  
-  SILC_LOG_DEBUG(("Start"));
+  SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
  
   chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
   if (!chid)
@@ -1641,7 +1733,8 @@ void silc_server_send_channel_key(SilcServer server,
                                            channel->key_len / 8, channel->key);
   silc_server_packet_send_to_channel(server, sender, channel, 
 				     SILC_PACKET_CHANNEL_KEY,
-                                     route, packet->data, packet->len, FALSE);
+                                     route, packet->data, packet->len, 
+				     FALSE);
   silc_buffer_free(packet);
   silc_free(chid);
 }
@@ -1667,6 +1760,55 @@ void silc_server_send_command(SilcServer server,
   va_end(ap);
 }
 
+/* Generic function to send any command reply. The arguments must be sent
+   already encoded into correct form in correct order. */
+
+void silc_server_send_command_reply(SilcServer server, 
+				    SilcSocketConnection sock,
+				    SilcCommand command, 
+				    SilcCommandStatus status,
+				    uint16 ident,
+				    uint32 argc, ...)
+{
+  SilcBuffer packet;
+  va_list ap;
+
+  va_start(ap, argc);
+
+  packet = silc_command_reply_payload_encode_vap(command, status, ident, 
+						 argc, ap);
+  silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
+			  packet->data, packet->len, TRUE);
+  silc_buffer_free(packet);
+  va_end(ap);
+}
+
+/* Generic function to send any command reply. The arguments must be sent
+   already encoded into correct form in correct order. */
+
+void silc_server_send_dest_command_reply(SilcServer server, 
+					 SilcSocketConnection sock,
+					 void *dst_id,
+					 SilcIdType dst_id_type,
+					 SilcCommand command, 
+					 SilcCommandStatus status,
+					 uint16 ident,
+					 uint32 argc, ...)
+{
+  SilcBuffer packet;
+  va_list ap;
+
+  va_start(ap, argc);
+
+  packet = silc_command_reply_payload_encode_vap(command, status, ident, 
+						 argc, ap);
+  silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
+			       dst_id, dst_id_type, packet->data, 
+			       packet->len, TRUE);
+  silc_buffer_free(packet);
+  va_end(ap);
+}
+
 /* Send the heartbeat packet. */
 
 void silc_server_send_heartbeat(SilcServer server,