printf -> writeln

6 files changed, 77 insertions, 77 deletions

diff --git a/rdp/rdp.c b/rdp/rdp.c
index 8289cdbb..4c0d1a21 100644
--- a/rdp/rdp.c
+++ b/rdp/rdp.c
@@ -27,14 +27,14 @@
 int DEFAULT_CC
 lib_mod_start(struct mod* mod, int w, int h, int bpp)
 {
-  DEBUG(("in lib_mod_start\r\n"));
+  DEBUG(("in lib_mod_start"));
   mod->width = w;
   mod->height = h;
   mod->rdp_bpp = bpp;
   mod->xrdp_bpp = bpp;
   mod->keylayout = 0x409;
   g_strncpy(mod->port, "3389", 255); /* default */
-  DEBUG(("out lib_mod_start\r\n"));
+  DEBUG(("out lib_mod_start"));
   return 0;
 }
 
@@ -43,7 +43,7 @@ lib_mod_start(struct mod* mod, int w, int h, int bpp)
 int DEFAULT_CC
 lib_mod_connect(struct mod* mod)
 {
-  DEBUG(("in lib_mod_connect\r\n"));
+  DEBUG(("in lib_mod_connect"));
   /* clear screen */
   mod->server_begin_update(mod);
   mod->server_set_fgcolor(mod, 0);
@@ -53,10 +53,10 @@ lib_mod_connect(struct mod* mod)
   if (rdp_rdp_connect(mod->rdp_layer, mod->ip, mod->port) == 0)
   {
     mod->sck = mod->rdp_layer->sec_layer->mcs_layer->iso_layer->tcp_layer->sck;
-    DEBUG(("out lib_mod_connect\r\n"));
+    DEBUG(("out lib_mod_connect"));
     return 0;
   }
-  DEBUG(("out lib_mod_connect error\r\n"));
+  DEBUG(("out lib_mod_connect error"));
   return 1;
 }
 
@@ -72,7 +72,7 @@ lib_mod_event(struct mod* mod, int msg, long param1, long param2,
   {
     return 0;
   }
-  DEBUG(("in lib_mod_event\r\n"));
+  DEBUG(("in lib_mod_event"));
   make_stream(s);
   init_stream(s, 8192 * 2);
   switch (msg)
@@ -145,7 +145,7 @@ lib_mod_event(struct mod* mod, int msg, long param1, long param2,
       break;
   }
   free_stream(s);
-  DEBUG(("out lib_mod_event\r\n"));
+  DEBUG(("out lib_mod_event"));
   return 0;
 }
 
@@ -158,7 +158,7 @@ lib_mod_signal(struct mod* mod)
   int cont;
   struct stream* s;
 
-  DEBUG(("in lib_mod_signal\r\n"));
+  DEBUG(("in lib_mod_signal"));
   if (mod->in_s == 0)
   {
     make_stream(mod->in_s);
@@ -171,10 +171,10 @@ lib_mod_signal(struct mod* mod)
     type = 0;
     if (rdp_rdp_recv(mod->rdp_layer, s, &type) != 0)
     {
-      DEBUG(("out lib_mod_signal error rdp_rdp_recv failed\r\n"));
+      DEBUG(("out lib_mod_signal error rdp_rdp_recv failed"));
       return 1;
     }
-    DEBUG(("lib_mod_signal type %d\r\n", type));
+    DEBUG(("lib_mod_signal type %d", type));
     switch (type)
     {
       case RDP_PDU_DATA:
@@ -196,7 +196,7 @@ lib_mod_signal(struct mod* mod)
     }
     cont = s->next_packet < s->end;
   }
-  DEBUG(("out lib_mod_signal\r\n"));
+  DEBUG(("out lib_mod_signal"));
   return 0;
 }
 
@@ -255,7 +255,7 @@ mod_init(void)
 {
   struct mod* mod;
 
-  DEBUG(("in mod_init\r\n"));
+  DEBUG(("in mod_init"));
   mod = (struct mod*)g_malloc(sizeof(struct mod), 1);
   mod->size = sizeof(struct mod);
   mod->handle = (long)mod;
@@ -266,7 +266,7 @@ mod_init(void)
   mod->mod_end = lib_mod_end;
   mod->mod_set_param = lib_mod_set_param;
   mod->rdp_layer = rdp_rdp_create(mod);
-  DEBUG(("out mod_init\r\n"));
+  DEBUG(("out mod_init"));
   return mod;
 }
 
@@ -274,8 +274,8 @@ mod_init(void)
 int EXPORT_CC
 mod_exit(struct mod* mod)
 {
-  DEBUG(("in mod_exit\r\n"));
+  DEBUG(("in mod_exit"));
   g_free(mod);
-  DEBUG(("out mod_exit\r\n"));
+  DEBUG(("out mod_exit"));
   return 0;
 }
diff --git a/rdp/rdp_iso.c b/rdp/rdp_iso.c
index 6c46ee06..0f68f2a8 100644
--- a/rdp/rdp_iso.c
+++ b/rdp/rdp_iso.c
@@ -57,20 +57,20 @@ rdp_iso_recv_msg(struct rdp_iso* self, struct stream* s, int* code)
   *code = 0;
   if (rdp_tcp_recv(self->tcp_layer, s, 4) != 0)
   {
-    DEBUG(("   out rdp_iso_recv_msg error rdp_tcp_recv 1 failed\r\n"));
+    DEBUG(("   out rdp_iso_recv_msg error rdp_tcp_recv 1 failed"));
     return 1;
   }
   in_uint8(s, ver);
   if (ver != 3)
   {
-    DEBUG(("   out rdp_iso_recv_msg error ver != 3\r\n"));
+    DEBUG(("   out rdp_iso_recv_msg error ver != 3"));
     return 1;
   }
   in_uint8s(s, 1);
   in_uint16_be(s, len);
   if (rdp_tcp_recv(self->tcp_layer, s, len - 4) != 0)
   {
-    DEBUG(("   out rdp_iso_recv_msg error rdp_tcp_recv 2 failed\r\n"));
+    DEBUG(("   out rdp_iso_recv_msg error rdp_tcp_recv 2 failed"));
     return 1;
   }
   in_uint8s(s, 1);
@@ -168,20 +168,20 @@ rdp_iso_connect(struct rdp_iso* self, char* ip, char* port)
   int code;
   struct stream* s;
 
-  DEBUG(("   in rdp_iso_connect\r\n"));
+  DEBUG(("   in rdp_iso_connect"));
   make_stream(s);
   init_stream(s, 8192);
   if (rdp_tcp_connect(self->tcp_layer, ip, port) != 0)
   {
     free_stream(s);
-    DEBUG(("   out rdp_iso_connect error rdp_tcp_connect failed\r\n"));
+    DEBUG(("   out rdp_iso_connect error rdp_tcp_connect failed"));
     return 1;
   }
   if (rdp_iso_send_msg(self, s, ISO_PDU_CR) != 0)
   {
     free_stream(s);
     rdp_tcp_disconnect(self->tcp_layer);
-    DEBUG(("   out rdp_iso_connect error rdp_iso_send_msg failed\r\n"));
+    DEBUG(("   out rdp_iso_connect error rdp_iso_send_msg failed"));
     return 1;
   }
   init_stream(s, 8192);
@@ -189,18 +189,18 @@ rdp_iso_connect(struct rdp_iso* self, char* ip, char* port)
   {
     free_stream(s);
     rdp_tcp_disconnect(self->tcp_layer);
-    DEBUG(("   out rdp_iso_connect error rdp_iso_recv_msg failed\r\n"));
+    DEBUG(("   out rdp_iso_connect error rdp_iso_recv_msg failed"));
     return 1;
   }
   if (code != ISO_PDU_CC)
   {
     free_stream(s);
     rdp_tcp_disconnect(self->tcp_layer);
-    DEBUG(("   out rdp_iso_connect error code != ISO_PDU_CC\r\n"));
+    DEBUG(("   out rdp_iso_connect error code != ISO_PDU_CC"));
     return 1;
   }
   free_stream(s);
-  DEBUG(("   out rdp_iso_connect\r\n"));
+  DEBUG(("   out rdp_iso_connect"));
   return 0;
 }
 
diff --git a/rdp/rdp_mcs.c b/rdp/rdp_mcs.c
index 0822e684..7c6e2f4c 100644
--- a/rdp/rdp_mcs.c
+++ b/rdp/rdp_mcs.c
@@ -60,7 +60,7 @@ rdp_mcs_recv(struct rdp_mcs* self, struct stream* s, int* chan)
   int opcode;
   int len;
 
-  DEBUG(("  in rdp_mcs_recv\r\n"));
+  DEBUG(("  in rdp_mcs_recv"));
   if (rdp_iso_recv(self->iso_layer, s) != 0)
   {
     return 1;
@@ -69,7 +69,7 @@ rdp_mcs_recv(struct rdp_mcs* self, struct stream* s, int* chan)
   appid = opcode >> 2;
   if (appid != MCS_SDIN)
   {
-    DEBUG(("  out rdp_mcs_recv error\r\n"));
+    DEBUG(("  out rdp_mcs_recv error"));
     return 1;
   }
   in_uint8s(s, 2);
@@ -80,7 +80,7 @@ rdp_mcs_recv(struct rdp_mcs* self, struct stream* s, int* chan)
   {
     in_uint8s(s, 1);
   }
-  DEBUG(("  out rdp_mcs_recv\r\n"));
+  DEBUG(("  out rdp_mcs_recv"));
   return 0;
 }
 
@@ -489,10 +489,10 @@ rdp_mcs_recv_cjcf(struct rdp_mcs* self)
 int APP_CC
 rdp_mcs_connect(struct rdp_mcs* self, char* ip, char* port)
 {
-  DEBUG(("  in rdp_mcs_connect\r\n"));
+  DEBUG(("  in rdp_mcs_connect"));
   if (rdp_iso_connect(self->iso_layer, ip, port) != 0)
   {
-    DEBUG(("  out rdp_mcs_connect error rdp_iso_connect failed\r\n"));
+    DEBUG(("  out rdp_mcs_connect error rdp_iso_connect failed"));
     return 1;
   }
   rdp_mcs_send_connection_initial(self);
@@ -500,7 +500,7 @@ rdp_mcs_connect(struct rdp_mcs* self, char* ip, char* port)
   {
     rdp_iso_disconnect(self->iso_layer);
     DEBUG(("  out rdp_mcs_connect error rdp_mcs_recv_connection_response \
-failed\r\n"));
+failed"));
     return 1;
   }
   rdp_mcs_send_edrq(self);
@@ -508,24 +508,24 @@ failed\r\n"));
   if (rdp_mcs_recv_aucf(self) != 0)
   {
     rdp_iso_disconnect(self->iso_layer);
-    DEBUG(("  out rdp_mcs_connect error rdp_mcs_recv_aucf failed\r\n"));
+    DEBUG(("  out rdp_mcs_connect error rdp_mcs_recv_aucf failed"));
     return 1;
   }
   rdp_mcs_send_cjrq(self, self->userid + 1001);
   if (rdp_mcs_recv_cjcf(self) != 0)
   {
     rdp_iso_disconnect(self->iso_layer);
-    DEBUG(("  out rdp_mcs_connect error rdp_mcs_recv_cjcf 1 failed\r\n"));
+    DEBUG(("  out rdp_mcs_connect error rdp_mcs_recv_cjcf 1 failed"));
     return 1;
   }
   rdp_mcs_send_cjrq(self, MCS_GLOBAL_CHANNEL);
   if (rdp_mcs_recv_cjcf(self) != 0)
   {
     rdp_iso_disconnect(self->iso_layer);
-    DEBUG(("  out rdp_mcs_connect error rdp_mcs_recv_cjcf 2 failed\r\n"));
+    DEBUG(("  out rdp_mcs_connect error rdp_mcs_recv_cjcf 2 failed"));
     return 1;
   }
-  DEBUG(("  out rdp_mcs_connect\r\n"));
+  DEBUG(("  out rdp_mcs_connect"));
   return 0;
 }
 
diff --git a/rdp/rdp_rdp.c b/rdp/rdp_rdp.c
index 00b8fa57..72fcf260 100644
--- a/rdp/rdp_rdp.c
+++ b/rdp/rdp_rdp.c
@@ -666,7 +666,7 @@ rdp_rdp_send_login_info(struct rdp_rdp* self, int flags)
   int sec_flags;
   struct stream* s;
 
-  DEBUG(("in rdp_rdp_send_login_info\r\n"));
+  DEBUG(("in rdp_rdp_send_login_info"));
   make_stream(s);
   init_stream(s, 8192);
   len_domain = 2 * g_strlen(self->mod->domain);
@@ -678,7 +678,7 @@ rdp_rdp_send_login_info(struct rdp_rdp* self, int flags)
   if (rdp_sec_init(self->sec_layer, s, sec_flags) != 0)
   {
     free_stream(s);
-    DEBUG(("out rdp_rdp_send_login_info error 1\r\n"));
+    DEBUG(("out rdp_rdp_send_login_info error 1"));
     return 1;
   }
   out_uint32_le(s, 0);
@@ -697,11 +697,11 @@ rdp_rdp_send_login_info(struct rdp_rdp* self, int flags)
   if (rdp_sec_send(self->sec_layer, s, sec_flags) != 0)
   {
     free_stream(s);
-    DEBUG(("out rdp_rdp_send_login_info error 2\r\n"));
+    DEBUG(("out rdp_rdp_send_login_info error 2"));
     return 1;
   }
   free_stream(s);
-  DEBUG(("out rdp_rdp_send_login_info\r\n"));
+  DEBUG(("out rdp_rdp_send_login_info"));
   return 0;
 }
 
@@ -711,7 +711,7 @@ rdp_rdp_connect(struct rdp_rdp* self, char* ip, char* port)
 {
   int flags;
 
-  DEBUG(("in rdp_rdp_connect\r\n"));
+  DEBUG(("in rdp_rdp_connect"));
   flags = RDP_LOGON_NORMAL;
   if (g_strlen(self->mod->password) > 0)
   {
@@ -719,15 +719,15 @@ rdp_rdp_connect(struct rdp_rdp* self, char* ip, char* port)
   }
   if (rdp_sec_connect(self->sec_layer, ip, port) != 0)
   {
-    DEBUG(("out rdp_rdp_connect error rdp_sec_connect failed\r\n"));
+    DEBUG(("out rdp_rdp_connect error rdp_sec_connect failed"));
     return 1;
   }
   if (rdp_rdp_send_login_info(self, flags) != 0)
   {
-    DEBUG(("out rdp_rdp_connect error rdp_rdp_send_login_info failed\r\n"));
+    DEBUG(("out rdp_rdp_connect error rdp_rdp_send_login_info failed"));
     return 1;
   }
-  DEBUG(("out rdp_rdp_connect\r\n"));
+  DEBUG(("out rdp_rdp_connect"));
   return 0;
 }
 
@@ -787,12 +787,12 @@ rdp_rdp_recv(struct rdp_rdp* self, struct stream* s, int* type)
   int chan;
 
   chan = 0;
-  DEBUG(("in rdp_rdp_recv\r\n"));
+  DEBUG(("in rdp_rdp_recv"));
   if (s->next_packet >= s->end || s->next_packet == 0)
   {
     if (rdp_sec_recv(self->sec_layer, s, &chan) != 0)
     {
-      DEBUG(("error in rdp_rdp_recv, rdp_sec_recv failed\r\n"));
+      DEBUG(("error in rdp_rdp_recv, rdp_sec_recv failed"));
       return 1;
     }
     s->next_packet = s->p;
@@ -805,11 +805,11 @@ rdp_rdp_recv(struct rdp_rdp* self, struct stream* s, int* type)
   if (chan == MCS_GLOBAL_CHANNEL)
   {
     in_uint16_le(s, len);
-    DEBUG(("rdp_rdp_recv got %d len\r\n", len));
+    DEBUG(("rdp_rdp_recv got %d len", len));
     if (len == 0x8000)
     {
       s->next_packet += 8;
-      DEBUG(("out rdp_rdp_recv\r\n"));
+      DEBUG(("out rdp_rdp_recv"));
       return 0;
     }
     in_uint16_le(s, pdu_type);
@@ -820,10 +820,10 @@ rdp_rdp_recv(struct rdp_rdp* self, struct stream* s, int* type)
   else
   {
     /* todo, process channel data */
-    DEBUG(("got channel data channel %d\r\n", chan));
+    DEBUG(("got channel data channel %d", chan));
     s->next_packet = s->end;
   }
-  DEBUG(("out rdp_rdp_recv\r\n"));
+  DEBUG(("out rdp_rdp_recv"));
   return 0;
 }
 
diff --git a/rdp/rdp_sec.c b/rdp/rdp_sec.c
index 1fca5141..881d4af7 100644
--- a/rdp/rdp_sec.c
+++ b/rdp/rdp_sec.c
@@ -138,14 +138,14 @@ rdp_sec_recv(struct rdp_sec* self, struct stream* s, int* chan)
 {
   int flags;
 
-  DEBUG((" in rdp_sec_recv\r\n"));
+  DEBUG((" in rdp_sec_recv"));
   if (rdp_mcs_recv(self->mcs_layer, s, chan) != 0)
   {
-    DEBUG((" error in rdp_sec_recv, rdp_mcs_recv failed\r\n"));
+    DEBUG((" error in rdp_sec_recv, rdp_mcs_recv failed"));
     return 1;
   }
   in_uint32_le(s, flags);
-  DEBUG((" rdp_sec_recv flags %8.8x\r\n", flags));
+  DEBUG((" rdp_sec_recv flags %8.8x", flags));
   if (flags & SEC_ENCRYPT) /* 0x08 */
   {
     in_uint8s(s, 8); /* signature */
@@ -153,11 +153,11 @@ rdp_sec_recv(struct rdp_sec* self, struct stream* s, int* chan)
   }
   if (flags & SEC_LICENCE_NEG) /* 0x80 */
   {
-    DEBUG((" in rdp_sec_recv, got SEC_LICENCE_NEG\r\n"));
+    DEBUG((" in rdp_sec_recv, got SEC_LICENCE_NEG"));
     rdp_lic_process(self->lic_layer, s);
     *chan = 0;
   }
-  DEBUG((" out rdp_sec_recv\r\n"));
+  DEBUG((" out rdp_sec_recv"));
   return 0;
 }
 
@@ -297,7 +297,7 @@ rdp_sec_parse_crypt_info(struct rdp_sec* self, struct stream* s,
       in_uint16_le(s, tag);
       in_uint16_le(s, length);
       next_tag = s->p + length;
-      DEBUG((" rdp_sec_parse_crypt_info tag %d length %d\r\n", tag, length));
+      DEBUG((" rdp_sec_parse_crypt_info tag %d length %d", tag, length));
       switch (tag)
       {
         case SEC_TAG_PUBKEY:
@@ -398,8 +398,8 @@ rdp_sec_generate_keys(struct rdp_sec* self)
                   self->server_random);
   rdp_sec_hash_16(self->encrypt_key, session_key + 32, self->client_random,
                   self->server_random);
-  DEBUG((" rdp_sec_generate_keys, rc4_key_size is %d\r\n", self->rc4_key_size));
-  DEBUG((" rdp_sec_generate_keys, crypt_level is %d\r\n", self->crypt_level));
+  DEBUG((" rdp_sec_generate_keys, rc4_key_size is %d", self->rc4_key_size));
+  DEBUG((" rdp_sec_generate_keys, crypt_level is %d", self->crypt_level));
   if (self->rc4_key_size == 1)
   {
     rdp_sec_make_40bit(self->sign_key);
@@ -430,7 +430,7 @@ rdp_sec_process_crypt_info(struct rdp_sec* self, struct stream* s)
   g_memset(exponent, 0, sizeof(exponent));
   if (!rdp_sec_parse_crypt_info(self, s, modulus, exponent))
   {
-    DEBUG((" error in rdp_sec_process_crypt_info\r\n"));
+    DEBUG((" error in rdp_sec_process_crypt_info"));
     return;
   }
   /* Generate a client random, and determine encryption keys */
@@ -463,7 +463,7 @@ rdp_sec_process_mcs_data(struct rdp_sec* self)
   {
     in_uint16_le(s, tag);
     in_uint16_le(s, length);
-    DEBUG((" rdp_sec_process_mcs_data tag %d length %d\r\n", tag, length));
+    DEBUG((" rdp_sec_process_mcs_data tag %d length %d", tag, length));
     if (length <= 4)
     {
       return;
@@ -496,7 +496,7 @@ rdp_sec_establish_key(struct rdp_sec* self)
   int flags;
   struct stream* s;
 
-  DEBUG((" sending client random\r\n"));
+  DEBUG((" sending client random"));
   make_stream(s);
   init_stream(s, 8192);
   length = SEC_MODULUS_SIZE + SEC_PADDING_SIZE;
@@ -524,20 +524,20 @@ rdp_sec_establish_key(struct rdp_sec* self)
 int APP_CC
 rdp_sec_connect(struct rdp_sec* self, char* ip, char* port)
 {
-  DEBUG((" in rdp_sec_connect\r\n"));
+  DEBUG((" in rdp_sec_connect"));
   rdp_sec_out_mcs_data(self);
   if (rdp_mcs_connect(self->mcs_layer, ip, port) != 0)
   {
-    DEBUG((" out rdp_sec_connect error rdp_mcs_connect failed\r\n"));
+    DEBUG((" out rdp_sec_connect error rdp_mcs_connect failed"));
     return 1;
   }
   rdp_sec_process_mcs_data(self);
   if (rdp_sec_establish_key(self) != 0)
   {
-    DEBUG((" out rdp_sec_connect error rdp_sec_establish_key failed\r\n"));
+    DEBUG((" out rdp_sec_connect error rdp_sec_establish_key failed"));
     return 1;
   }
-  DEBUG((" out rdp_sec_connect\r\n"));
+  DEBUG((" out rdp_sec_connect"));
   return 0;
 }
 
@@ -627,7 +627,7 @@ rdp_sec_send(struct rdp_sec* self, struct stream* s, int flags)
 {
   int datalen;
 
-  DEBUG((" in rdp_sec_send flags %8.8x\r\n", flags));
+  DEBUG((" in rdp_sec_send flags %8.8x", flags));
   s_pop_layer(s, sec_hdr);
   out_uint32_le(s, flags);
   if (flags & SEC_ENCRYPT)
@@ -639,9 +639,9 @@ rdp_sec_send(struct rdp_sec* self, struct stream* s, int flags)
   }
   if (rdp_mcs_send(self->mcs_layer, s) != 0)
   {
-    DEBUG((" out rdp_sec_send, rdp_mcs_send failed\r\n"));
+    DEBUG((" out rdp_sec_send, rdp_mcs_send failed"));
     return 1;
   }
-  DEBUG((" out rdp_sec_send\r\n"));
+  DEBUG((" out rdp_sec_send"));
   return 0;
 }
diff --git a/rdp/rdp_tcp.c b/rdp/rdp_tcp.c
index 83187860..0283ba1d 100644
--- a/rdp/rdp_tcp.c
+++ b/rdp/rdp_tcp.c
@@ -57,11 +57,11 @@ rdp_tcp_recv(struct rdp_tcp* self, struct stream* s, int len)
 {
   int rcvd;
 
-  DEBUG(("    in rdp_tcp_recv gota get %d bytes on sck %d\r\n",
+  DEBUG(("    in rdp_tcp_recv gota get %d bytes on sck %d",
          len, self->sck));
   if (self->sck_closed)
   {
-    DEBUG(("    out rdp_tcp_recv error sck closed\r\n"));
+    DEBUG(("    out rdp_tcp_recv error sck closed"));
     return 1;
   }
   init_stream(s, len);
@@ -77,14 +77,14 @@ rdp_tcp_recv(struct rdp_tcp* self, struct stream* s, int len)
       else
       {
         self->sck_closed = 1;
-        DEBUG(("    out rdp_tcp_recv error unknown\r\n"));
+        DEBUG(("    out rdp_tcp_recv error unknown"));
         return 1;
       }
     }
     else if (rcvd == 0)
     {
       self->sck_closed = 1;
-      DEBUG(("    out rdp_tcp_recv error connection dropped\r\n"));
+      DEBUG(("    out rdp_tcp_recv error connection dropped"));
       return 1;
     }
     else
@@ -107,11 +107,11 @@ rdp_tcp_send(struct rdp_tcp* self, struct stream* s)
 
   if (self->sck_closed)
   {
-    DEBUG(("    out rdp_tcp_send error sck closed\r\n"));
+    DEBUG(("    out rdp_tcp_send error sck closed"));
     return 1;
   }
   len = s->end - s->data;
-  DEBUG(("    in rdp_tcp_send gota send %d bytes on sck %d\r\n", len,
+  DEBUG(("    in rdp_tcp_send gota send %d bytes on sck %d", len,
          self->sck));
   total = 0;
   while (total < len)
@@ -126,14 +126,14 @@ rdp_tcp_send(struct rdp_tcp* self, struct stream* s)
       else
       {
         self->sck_closed = 1;
-        DEBUG(("    out rdp_tcp_send error unknown\r\n"));
+        DEBUG(("    out rdp_tcp_send error unknown"));
         return 1;
       }
     }
     else if (sent == 0)
     {
       self->sck_closed = 1;
-      DEBUG(("    out rdp_tcp_send error connection dropped\r\n"));
+      DEBUG(("    out rdp_tcp_send error connection dropped"));
       return 1;
     }
     else
@@ -149,7 +149,7 @@ rdp_tcp_send(struct rdp_tcp* self, struct stream* s)
 int APP_CC
 rdp_tcp_connect(struct rdp_tcp* self, char* ip, char* port)
 {
-  DEBUG(("    in rdp_tcp_connect ip %s port %s\r\n", ip, port));
+  DEBUG(("    in rdp_tcp_connect ip %s port %s", ip, port));
   self->sck = g_tcp_socket();
   if (g_tcp_connect(self->sck, ip, port) == 0)
   {
@@ -157,10 +157,10 @@ rdp_tcp_connect(struct rdp_tcp* self, char* ip, char* port)
   }
   else
   {
-    DEBUG(("    out rdp_tcp_connect error g_tcp_connect failed\r\n"));
+    DEBUG(("    out rdp_tcp_connect error g_tcp_connect failed"));
     return 1;
   }
-  DEBUG(("    out rdp_tcp_connect\r\n"));
+  DEBUG(("    out rdp_tcp_connect"));
   return 0;
 }