开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
http.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：21k
源码类别：

Windows CE

开发平台：

C/C++

http.c：源码内容
  1. /*  XMMS - Cross-platform multimedia player
  2.  *  Copyright (C) 1998-2000  Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies
  3.  *
  4.  *  This program is free software; you can redistribute it and/or modify
  5.  *  it under the terms of the GNU General Public License as published by
  6.  *  the Free Software Foundation; either version 2 of the License, or
  7.  *  (at your option) any later version.
  8.  *
  9.  *  This program is distributed in the hope that it will be useful,
  10.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *  GNU General Public License for more details.
  13.  *
  14.  *  You should have received a copy of the GNU General Public License
  15.  *  along with this program; if not, write to the Free Software
  16.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18. /* modified for FLAC support by Steven Richman (2003) */
  19. #include <sys/types.h>
  20. #include <sys/socket.h>
  21. #include <sys/time.h>
  22. #include <netinet/in.h>
  23. #include <arpa/inet.h>
  24. #include <netdb.h>
  25. #include <glib.h>
  26. #include <string.h>
  27. #include <fcntl.h>
  28. #include <unistd.h>
  29. #include <errno.h>
  30. #include <stdio.h>
  31. #include <stdlib.h>
  33. #include <pthread.h>
  35. #include <xmms/util.h>
  36. #include <xmms/plugin.h>
  38. #ifdef HAVE_CONFIG_H
  39. #include <config.h>
  40. #endif
  42. #include "configure.h"
  43. #include "plugin_common/locale_hack.h"
  44. #include "FLAC/format.h"
  45. #include "plugin.h"
  47. #ifndef HAVE_SOCKLEN_T
  48. typedef unsigned int socklen_t;
  49. #endif
  51. #define min(x,y) ((x)<(y)?(x):(y))
  52. #define min3(x,y,z) (min(x,y)<(z)?min(x,y):(z))
  53. #define min4(x,y,z,w) (min3(x,y,z)<(w)?min3(x,y,z):(w))
  55. static gchar *icy_name = NULL;
  56. static gint icy_metaint = 0;
  58. extern InputPlugin flac_ip;
  60. #undef DEBUG_UDP
  62. /* Static udp channel functions */
  63. static int udp_establish_listener (gint *sock);
  64. static int udp_check_for_data(gint sock);
  66. static char *flac_http_get_title(char *url);
  68. static gboolean prebuffering, going, eof = FALSE;
  69. static gint sock, rd_index, wr_index, buffer_length, prebuffer_length;
  70. static guint64 buffer_read = 0;
  71. static gchar *buffer;
  72. static guint64 offset;
  73. static pthread_t thread;
  74. static GtkWidget *error_dialog = NULL;
  76. static FILE *output_file = NULL;
  78. #define BASE64_LENGTH(len) (4 * (((len) + 2) / 3))
  80. /* Encode the string S of length LENGTH to base64 format and place it
  81.    to STORE.  STORE will be 0-terminated, and must point to a writable
  82.    buffer of at least 1+BASE64_LENGTH(length) bytes.  */
  83. static void base64_encode (const gchar *s, gchar *store, gint length)
  84. {
  85. /* Conversion table.  */
  86. static gchar tbl[64] = {
  87. 'A','B','C','D','E','F','G','H',
  88. 'I','J','K','L','M','N','O','P',
  89. 'Q','R','S','T','U','V','W','X',
  90. 'Y','Z','a','b','c','d','e','f',
  91. 'g','h','i','j','k','l','m','n',
  92. 'o','p','q','r','s','t','u','v',
  93. 'w','x','y','z','0','1','2','3',
  94. '4','5','6','7','8','9','+','/'
  95. };
  96. gint i;
  97. guchar *p = (guchar *)store;
  99. /* Transform the 3x8 bits to 4x6 bits, as required by base64.  */
  100. for (i = 0; i < length; i += 3)
  101. {
  102. *p++ = tbl[s[0] >> 2];
  103. *p++ = tbl[((s[0] & 3) << 4) + (s[1] >> 4)];
  104. *p++ = tbl[((s[1] & 0xf) << 2) + (s[2] >> 6)];
  105. *p++ = tbl[s[2] & 0x3f];
  106. s += 3;
  107. }
  108. /* Pad the result if necessary...  */
  109. if (i == length + 1)
  110. *(p - 1) = '=';
  111. else if (i == length + 2)
  112. *(p - 1) = *(p - 2) = '=';
  113. /* ...and zero-terminate it.  */
  114. *p = '';
  115. }
  117. /* Create the authentication header contents for the `Basic' scheme.
  118.    This is done by encoding the string `USER:PASS' in base64 and
  119.    prepending `HEADER: Basic ' to it.  */
  120. static gchar *basic_authentication_encode (const gchar *user, const gchar *passwd, const gchar *header)
  121. {
  122. gchar *t1, *t2, *res;
  123. gint len1 = strlen (user) + 1 + strlen (passwd);
  124. gint len2 = BASE64_LENGTH (len1);
  126. t1 = g_strdup_printf("%s:%s", user, passwd);
  127. t2 = g_malloc0(len2 + 1);
  128. base64_encode (t1, t2, len1);
  129. res = g_strdup_printf("%s: Basic %srn", header, t2);
  130. g_free(t2);
  131. g_free(t1);
  133. return res;
  134. }
  136. static void parse_url(const gchar * url, gchar ** user, gchar ** pass, gchar ** host, int *port, gchar ** filename)
  137. {
  138. gchar *h, *p, *pt, *f, *temp, *ptr;
  140. temp = g_strdup(url);
  141. ptr = temp;
  143. if (!strncasecmp("http://", ptr, 7))
  144. ptr += 7;
  145. h = strchr(ptr, '@');
  146. f = strchr(ptr, '/');
  147. if (h != NULL && (!f || h < f))
  148. {
  149. *h = '';
  150. p = strchr(ptr, ':');
  151. if (p != NULL && p < h)
  152. {
  153. *p = '';
  154. p++;
  155. *pass = g_strdup(p);
  156. }
  157. else
  158. *pass = NULL;
  159. *user = g_strdup(ptr);
  160. h++;
  161. ptr = h;
  162. }
  163. else
  164. {
  165. *user = NULL;
  166. *pass = NULL;
  167. h = ptr;
  168. }
  169. pt = strchr(ptr, ':');
  170. if (pt != NULL && (f == NULL || pt < f))
  171. {
  172. *pt = '';
  173. *port = atoi(pt + 1);
  174. }
  175. else
  176. {
  177. if (f)
  178. *f = '';
  179. *port = 80;
  180. }
  181. *host = g_strdup(h);
  183. if (f)
  184. *filename = g_strdup(f + 1);
  185. else
  186. *filename = NULL;
  187. g_free(temp);
  188. }
  190. void flac_http_close(void)
  191. {
  192. going = FALSE;
  194. pthread_join(thread, NULL);
  195. g_free(icy_name);
  196. icy_name = NULL;
  197. }
  200. static gint http_used(void)
  201. {
  202. if (wr_index >= rd_index)
  203. return wr_index - rd_index;
  204. return buffer_length - (rd_index - wr_index);
  205. }
  207. static gint http_free(void)
  208. {
  209. if (rd_index > wr_index)
  210. return (rd_index - wr_index) - 1;
  211. return (buffer_length - (wr_index - rd_index)) - 1;
  212. }
  214. static void http_wait_for_data(gint bytes)
  215. {
  216. while ((prebuffering || http_used() < bytes) && !eof && going)
  217. xmms_usleep(10000);
  218. }
  220. static void show_error_message(gchar *error)
  221. {
  222. if(!error_dialog)
  223. {
  224. GDK_THREADS_ENTER();
  225. error_dialog = xmms_show_message(_("Error"), error, _("Ok"), FALSE,
  226.  NULL, NULL);
  227. gtk_signal_connect(GTK_OBJECT(error_dialog),
  228.    "destroy",
  229.    GTK_SIGNAL_FUNC(gtk_widget_destroyed),
  230.    &error_dialog);
  231. GDK_THREADS_LEAVE();
  232. }
  233. }
  235. int flac_http_read(gpointer data, gint length)
  236. {
  237. gint len, cnt, off = 0, meta_len, meta_off = 0, i;
  238. gchar *meta_data, **tags, *temp, *title;
  239. if (length > buffer_length) {
  240. length = buffer_length;
  241. }
  243. http_wait_for_data(length);
  245. if (!going)
  246. return 0;
  247. len = min(http_used(), length);
  249. while (len && http_used())
  250. {
  251. if ((flac_cfg.stream.cast_title_streaming) && (icy_metaint > 0) && (buffer_read % icy_metaint) == 0 && (buffer_read > 0))
  252. {
  253. meta_len = *((guchar *) buffer + rd_index) * 16;
  254. rd_index = (rd_index + 1) % buffer_length;
  255. if (meta_len > 0)
  256. {
  257. http_wait_for_data(meta_len);
  258. meta_data = g_malloc0(meta_len);
  259. if (http_used() >= meta_len)
  260. {
  261. while (meta_len)
  262. {
  263. cnt = min(meta_len, buffer_length - rd_index);
  264. memcpy(meta_data + meta_off, buffer + rd_index, cnt);
  265. rd_index = (rd_index + cnt) % buffer_length;
  266. meta_len -= cnt;
  267. meta_off += cnt;
  268. }
  269. tags = g_strsplit(meta_data, "';", 0);
  271. for (i = 0; tags[i]; i++)
  272. {
  273. if (!strncasecmp(tags[i], "StreamTitle=", 12))
  274. {
  275. temp = g_strdup(tags[i] + 13);
  276. title = g_strdup_printf("%s (%s)", temp, icy_name);
  277. set_track_info(title, -1);
  278. g_free(title);
  279. g_free(temp);
  280. }
  282. }
  283. g_strfreev(tags);
  285. }
  286. g_free(meta_data);
  287. }
  288. if (!http_used())
  289. http_wait_for_data(length - off);
  290. cnt = min3(len, buffer_length - rd_index, http_used());
  291. }
  292. else if ((icy_metaint > 0) && (flac_cfg.stream.cast_title_streaming))
  293. cnt = min4(len, buffer_length - rd_index, http_used(), icy_metaint - (gint) (buffer_read % icy_metaint));
  294. else
  295. cnt = min3(len, buffer_length - rd_index, http_used());
  296. if (output_file)
  297. fwrite(buffer + rd_index, 1, cnt, output_file);
  299. memcpy((gchar *)data + off, buffer + rd_index, cnt);
  300. rd_index = (rd_index + cnt) % buffer_length;
  301. buffer_read += cnt;
  302. len -= cnt;
  303. off += cnt;
  304. }
  305. if (!off) {
  306. fprintf(stderr, "returning zeron");
  307. }
  308. return off;
  309. }
  311. static gboolean http_check_for_data(void)
  312. {
  314. fd_set set;
  315. struct timeval tv;
  316. gint ret;
  318. tv.tv_sec = 0;
  319. tv.tv_usec = 20000;
  320. FD_ZERO(&set);
  321. FD_SET(sock, &set);
  322. ret = select(sock + 1, &set, NULL, NULL, &tv);
  323. if (ret > 0)
  324. return TRUE;
  325. return FALSE;
  326. }
  328. gint flac_http_read_line(gchar * buf, gint size)
  329. {
  330. gint i = 0;
  332. while (going && i < size - 1)
  333. {
  334. if (http_check_for_data())
  335. {
  336. if (read(sock, buf + i, 1) <= 0)
  337. return -1;
  338. if (buf[i] == 'n')
  339. break;
  340. if (buf[i] != 'r')
  341. i++;
  342. }
  343. }
  344. if (!going)
  345. return -1;
  346. buf[i] = '';
  347. return i;
  348. }
  350. /* returns the file descriptor of the socket, or -1 on error */
  351. static int http_connect (gchar *url_, gboolean head, guint64 offset)
  352. {
  353. gchar line[1024], *user, *pass, *host, *filename,
  354.      *status, *url, *temp, *file;
  355. gchar *chost;
  356. gint cnt, error, err_len, port, cport;
  357. gboolean redirect;
  358. int udp_sock = 0;
  359. fd_set set;
  360. struct hostent *hp;
  361. struct sockaddr_in address;
  362. struct timeval tv;
  364. url = g_strdup (url_);
  366. do
  367. {
  368. redirect=FALSE;
  370. g_strstrip(url);
  372. parse_url(url, &user, &pass, &host, &port, &filename);
  374. if ((!filename || !*filename) && url[strlen(url) - 1] != '/')
  375. temp = g_strconcat(url, "/", NULL);
  376. else
  377. temp = g_strdup(url);
  378. g_free(url);
  379. url = temp;
  381. chost = flac_cfg.stream.use_proxy ? flac_cfg.stream.proxy_host : host;
  382. cport = flac_cfg.stream.use_proxy ? flac_cfg.stream.proxy_port : port;
  384. sock = socket(AF_INET, SOCK_STREAM, 0);
  385. fcntl(sock, F_SETFL, O_NONBLOCK);
  386. address.sin_family = AF_INET;
  388. status = g_strdup_printf(_("LOOKING UP %s"), chost);
  389. flac_ip.set_info_text(status);
  390. g_free(status);
  392. if (!(hp = gethostbyname(chost)))
  393. {
  394. status = g_strdup_printf(_("Couldn't look up host %s"), chost);
  395. show_error_message(status);
  396. g_free(status);
  398. flac_ip.set_info_text(NULL);
  399. eof = TRUE;
  400. }
  402. if (!eof)
  403. {
  404. memcpy(&address.sin_addr.s_addr, *(hp->h_addr_list), sizeof (address.sin_addr.s_addr));
  405. address.sin_port = (gint) g_htons(cport);
  407. status = g_strdup_printf(_("CONNECTING TO %s:%d"), chost, cport);
  408. flac_ip.set_info_text(status);
  409. g_free(status);
  410. if (connect(sock, (struct sockaddr *) &address, sizeof (struct sockaddr_in)) == -1)
  411. {
  412. if (errno != EINPROGRESS)
  413. {
  414. status = g_strdup_printf(_("Couldn't connect to host %s"), chost);
  415. show_error_message(status);
  416. g_free(status);
  418. flac_ip.set_info_text(NULL);
  419. eof = TRUE;
  420. }
  421. }
  422. while (going)
  423. {
  424. tv.tv_sec = 0;
  425. tv.tv_usec = 10000;
  426. FD_ZERO(&set);
  427. FD_SET(sock, &set);
  428. if (select(sock + 1, NULL, &set, NULL, &tv) > 0)
  429. {
  430. err_len = sizeof (error);
  431. getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &err_len);
  432. if (error)
  433. {
  434. status = g_strdup_printf(_("Couldn't connect to host %s"),
  435.  chost);
  436. show_error_message(status);
  437. g_free(status);
  439. flac_ip.set_info_text(NULL);
  440. eof = TRUE;
  442. }
  443. break;
  444. }
  445. }
  446. if (!eof)
  447. {
  448. gchar *auth = NULL, *proxy_auth = NULL;
  449. gchar udpspace[30];
  450. int udp_port;
  452. if (flac_cfg.stream.use_udp_channel)
  453. {
  454. udp_port = udp_establish_listener (&udp_sock);
  455. if (udp_port > 0) 
  456. sprintf (udpspace, "x-audiocast-udpport: %drn", udp_port);
  457. else
  458. udp_sock = 0;
  459. }
  461. if(user && pass)
  462. auth = basic_authentication_encode(user, pass, "Authorization");
  464. if (flac_cfg.stream.use_proxy)
  465. {
  466. file = g_strdup(url);
  467. if(flac_cfg.stream.proxy_use_auth && flac_cfg.stream.proxy_user && flac_cfg.stream.proxy_pass)
  468. {
  469. proxy_auth = basic_authentication_encode(flac_cfg.stream.proxy_user,
  470.  flac_cfg.stream.proxy_pass,
  471.  "Proxy-Authorization");
  472. }
  473. }
  474. else
  475. file = g_strconcat("/", filename, NULL);
  477. temp = g_strdup_printf("GET %s HTTP/1.0rn"
  478.        "Host: %srn"
  479.        "User-Agent: %s/%srn"
  480.        "%s%s%s%s",
  481.        file, host, "Reference FLAC Player", FLAC__VERSION_STRING, 
  482.        proxy_auth ? proxy_auth : "", auth ? auth : "",
  483.        flac_cfg.stream.cast_title_streaming ?  "Icy-MetaData:1rn" : "",
  484.        flac_cfg.stream.use_udp_channel ? udpspace : "");
  485. if (offset && !head) {
  486. gchar *temp_dead = temp;
  487. temp = g_strconcat ("%sRange: %ll-rn", temp, offset);
  488. fprintf (stderr, "%s", temp);
  489. g_free (temp_dead);
  490. }
  492. g_free(file);
  493. if(proxy_auth)
  494. g_free(proxy_auth);
  495. if(auth)
  496. g_free(auth);
  497. write(sock, temp, strlen(temp));
  498. write(sock, "rn", 2);
  499. g_free(temp);
  500. flac_ip.set_info_text(_("CONNECTED: WAITING FOR REPLY"));
  501. while (going && !eof)
  502.   {
  503. if (http_check_for_data())
  504. {
  505. if (flac_http_read_line(line, 1024))
  506. {
  507. status = strchr(line, ' ');
  508. if (status)
  509. {
  510. if (status[1] == '2')
  511. break;
  512. else if(status[1] == '3' && status[2] == '0' && status[3] == '2')
  513. {
  514. while(going)
  515. {
  516. if(http_check_for_data())
  517. {
  518. if((cnt = flac_http_read_line(line, 1024)) != -1)
  519. {
  520. if(!cnt)
  521. break;
  522. if(!strncmp(line, "Location:", 9))
  523. {
  524. g_free(url);
  525. url = g_strdup(line+10);
  526. }
  527. }
  528. else
  529. {
  530. eof=TRUE;
  531. flac_ip.set_info_text(NULL);
  532. break;
  533. }
  534. }
  535. }
  536. redirect=TRUE;
  537. break;
  538. }
  539. else
  540. {
  541. status = g_strdup_printf(_("Couldn't connect to host %snServer reported: %s"), chost, status);
  542. show_error_message(status);
  543. g_free(status);
  544. break;
  545. }
  546. }
  547. }
  548. else
  549. {
  550. eof = TRUE;
  551. flac_ip.set_info_text(NULL);
  552. }
  553. }
  554. }
  556. while (going && !redirect)
  557. {
  558. if (http_check_for_data())
  559. {
  560. if ((cnt = flac_http_read_line(line, 1024)) != -1)
  561. {
  562. if (!cnt)
  563. break;
  564. if (!strncmp(line, "icy-name:", 9))
  565. icy_name = g_strdup(line + 9);
  566. else if (!strncmp(line, "x-audiocast-name:", 17))
  567. icy_name = g_strdup(line + 17);
  568. if (!strncmp(line, "icy-metaint:", 12))
  569. icy_metaint = atoi(line + 12);
  570. if (!strncmp(line, "x-audiocast-udpport:", 20)) {
  571. #ifdef DEBUG_UDP
  572. fprintf (stderr, "Server wants udp messages on port %dn", atoi (line + 20));
  573. #endif
  574. /*udp_serverport = atoi (line + 20);*/
  575. }
  577. }
  578. else
  579. {
  580. eof = TRUE;
  581. flac_ip.set_info_text(NULL);
  582. break;
  583. }
  584. }
  585. }
  586. }
  587. }
  589. if(redirect)
  590. {
  591. if (output_file)
  592. {
  593. fclose(output_file);
  594. output_file = NULL;
  595. }
  596. close(sock);
  597. }
  599. g_free(user);
  600. g_free(pass);
  601. g_free(host);
  602. g_free(filename);
  603. } while(redirect);
  605. g_free(url);
  606. return eof ? -1 : sock;
  607. }
  609. static void *http_buffer_loop(void *arg)
  610. {
  611. gchar *status, *url, *temp, *file;
  612. gint cnt, written;
  613. int udp_sock = 0;
  615. url = (gchar *) arg;
  616. sock = http_connect (url, false, offset);
  618. if (sock >= 0 && flac_cfg.stream.save_http_stream) {
  619. gchar *output_name;
  620. file = flac_http_get_title(url);
  621. output_name = file;
  622. if (!strncasecmp(output_name, "http://", 7))
  623. output_name += 7;
  624. temp = strrchr(output_name, '.');
  625. if (temp && (!strcasecmp(temp, ".fla") || !strcasecmp(temp, ".flac")))
  626. *temp = '';
  628. while ((temp = strchr(output_name, '/')))
  629. *temp = '_';
  630. output_name = g_strdup_printf("%s/%s.flac", flac_cfg.stream.save_http_path, output_name);
  632. g_free(file);
  634. output_file = fopen(output_name, "wb");
  635. g_free(output_name);
  636. }
  638. while (going)
  639. {
  641. if (!http_used() && !flac_ip.output->buffer_playing())
  642. prebuffering = TRUE;
  643. if (http_free() > 0 && !eof)
  644. {
  645. if (http_check_for_data())
  646. {
  647. cnt = min(http_free(), buffer_length - wr_index);
  648. if (cnt > 1024)
  649. cnt = 1024;
  650. written = read(sock, buffer + wr_index, cnt);
  651. if (written <= 0)
  652. {
  653. eof = TRUE;
  654. if (prebuffering)
  655. {
  656. prebuffering = FALSE;
  658. flac_ip.set_info_text(NULL);
  659. }
  661. }
  662. else
  663. wr_index = (wr_index + written) % buffer_length;
  664. }
  666. if (prebuffering)
  667. {
  668. if (http_used() > prebuffer_length)
  669. {
  670. prebuffering = FALSE;
  671. flac_ip.set_info_text(NULL);
  672. }
  673. else
  674. {
  675. status = g_strdup_printf(_("PRE-BUFFERING: %dKB/%dKB"), http_used() / 1024, prebuffer_length / 1024);
  676. flac_ip.set_info_text(status);
  677. g_free(status);
  678. }
  680. }
  681. }
  682. else
  683. xmms_usleep(10000);
  685. if (flac_cfg.stream.use_udp_channel && udp_sock != 0)
  686. if (udp_check_for_data(udp_sock) < 0)
  687. {
  688. close(udp_sock);
  689. udp_sock = 0;
  690. }
  691. }
  692. if (output_file)
  693. {
  694. fclose(output_file);
  695. output_file = NULL;
  696. }
  697. if (sock >= 0) {
  698. close(sock);
  699. }
  700. if (udp_sock != 0)
  701. close(udp_sock);
  703. g_free(buffer);
  704. g_free(url);
  706. pthread_exit(NULL);
  707. return NULL; /* avoid compiler warning */
  708. }
  710. int flac_http_open(gchar * _url, guint64 _offset)
  711. {
  712. gchar *url;
  714. url = g_strdup(_url);
  716. rd_index = 0;
  717. wr_index = 0;
  718. buffer_length = flac_cfg.stream.http_buffer_size * 1024;
  719. prebuffer_length = (buffer_length * flac_cfg.stream.http_prebuffer) / 100;
  720. buffer_read = 0;
  721. icy_metaint = 0;
  722. prebuffering = TRUE;
  723. going = TRUE;
  724. eof = FALSE;
  725. buffer = g_malloc(buffer_length);
  726. offset = _offset;
  728. pthread_create(&thread, NULL, http_buffer_loop, url);
  730. return 0;
  731. }
  733. char *flac_http_get_title(char *url)
  734. {
  735. if (icy_name)
  736. return g_strdup(icy_name);
  737. if (g_basename(url) && strlen(g_basename(url)) > 0)
  738. return g_strdup(g_basename(url));
  739. return g_strdup(url);
  740. }
  742. /* Start UDP Channel specific stuff */
  744. /* Find a good local udp port and bind udp_sock to it, return the port */
  745. static int udp_establish_listener(int *sock)
  746. {
  747. struct sockaddr_in sin;
  748. socklen_t sinlen = sizeof (struct sockaddr_in);
  750. #ifdef DEBUG_UDP
  751. fprintf (stderr,"Establishing udp listenern");
  752. #endif
  754. if ((*sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  755. {
  756. g_log(NULL, G_LOG_LEVEL_CRITICAL,
  757.       "udp_establish_listener(): unable to create socket");
  758. return -1;
  759. }
  761. memset(&sin, 0, sinlen);
  762. sin.sin_family = AF_INET;
  763. sin.sin_addr.s_addr = g_htonl(INADDR_ANY);
  765. if (bind(*sock, (struct sockaddr *)&sin, sinlen) < 0)
  766. {
  767. g_log(NULL, G_LOG_LEVEL_CRITICAL,
  768.       "udp_establish_listener():  Failed to bind socket to localhost: %s", strerror(errno));
  769. close(*sock);
  770. return -1;
  771. }
  772. if (fcntl(*sock, F_SETFL, O_NONBLOCK) < 0)
  773. {
  774. g_log(NULL, G_LOG_LEVEL_CRITICAL,
  775.       "udp_establish_listener():  Failed to set flags: %s", strerror(errno));
  776. close(*sock);
  777. return -1;
  778. }
  780. memset(&sin, 0, sinlen);
  781. if (getsockname(*sock, (struct sockaddr *)&sin, &sinlen) < 0)
  782. {
  783. g_log(NULL, G_LOG_LEVEL_CRITICAL,
  784.       "udp_establish_listener():  Failed to retrieve socket info: %s", strerror(errno));
  785. close(*sock);
  786. return -1;
  787. }
  789. #ifdef DEBUG_UDP
  790. fprintf (stderr,"Listening on local %s:%dn", inet_ntoa(sin.sin_addr), g_ntohs(sin.sin_port));
  791. #endif
  793. return g_ntohs(sin.sin_port);
  794. }
  796. static int udp_check_for_data(int sock)
  797. {
  798. char buf[1025], **lines;
  799. char *valptr;
  800. gchar *title;
  801. gint len, i;
  802. struct sockaddr_in from;
  803. socklen_t fromlen;
  805. fromlen = sizeof(struct sockaddr_in);
  807. if ((len = recvfrom(sock, buf, 1024, 0, (struct sockaddr *)&from, &fromlen)) < 0)
  808. {
  809. if (errno != EAGAIN)
  810. {
  811. g_log(NULL, G_LOG_LEVEL_CRITICAL,
  812.       "udp_read_data(): Error reading from socket: %s", strerror(errno));
  813. return -1;
  814. }
  815. return 0;
  816. }
  817. buf[len] = '';
  818. #ifdef DEBUG_UDP
  819. fprintf (stderr,"Received: [%s]n", buf);
  820. #endif
  821. lines = g_strsplit(buf, "n", 0);
  822. if (!lines)
  823. return 0;
  825. for (i = 0; lines[i]; i++)
  826. {
  827. while ((lines[i][strlen(lines[i]) - 1] == 'n') ||
  828.        (lines[i][strlen(lines[i]) - 1] == 'r'))
  829. lines[i][strlen(lines[i]) - 1] = '';
  831. valptr = strchr(lines[i], ':');
  833. if (!valptr)
  834. continue;
  835. else
  836. valptr++;
  838. g_strstrip(valptr);
  839. if (!strlen(valptr))
  840. continue;
  842. if (strstr(lines[i], "x-audiocast-streamtitle") != NULL)
  843. {
  844. title = g_strdup_printf ("%s (%s)", valptr, icy_name);
  845. if (going)
  846. set_track_info(title, -1);
  847. g_free (title);
  848. }
  850. #if 0
  851. else if (strstr(lines[i], "x-audiocast-streamlength") != NULL)
  852. {
  853. if (atoi(valptr) != -1)
  854. set_track_info(NULL, atoi(valptr));
  855. }
  856. #endif
  858. else if (strstr(lines[i], "x-audiocast-streammsg") != NULL)
  859. {
  860. /* set_track_info(title, -1); */
  861. /*   xmms_show_message(_("Message"), valptr, _("Ok"), */
  862. /*     FALSE, NULL, NULL); */
  863. g_message("Stream_message: %s", valptr);
  864. }
  866. #if 0
  867. /* Use this to direct your webbrowser.. yeah right.. */
  868. else if (strstr(lines[i], "x-audiocast-streamurl") != NULL)
  869. {
  870. if (lasturl && g_strcmp (valptr, lasturl))
  871. {
  872. c_message (stderr, "Song URL: %sn", valptr);
  873. g_free (lasturl);
  874. lasturl = g_strdup (valptr);
  875. }
  876. }
  877. #endif
  878. else if (strstr(lines[i], "x-audiocast-udpseqnr:") != NULL)
  879. {
  880. gchar obuf[60];
  881. sprintf(obuf, "x-audiocast-ack: %ld rn", atol(valptr));
  882. if (sendto(sock, obuf, strlen(obuf), 0, (struct sockaddr *) &from, fromlen) < 0)
  883. {
  884. g_log(NULL, G_LOG_LEVEL_WARNING,
  885.       "udp_check_for_data(): Unable to send ack to server: %s", strerror(errno));
  886. }
  887. #ifdef DEBUG_UDP
  888. else
  889. fprintf(stderr,"Sent ack: %s", obuf);
  890. fprintf (stderr,"Remote: %s:%dn", inet_ntoa(from.sin_addr), g_ntohs(from.sin_port));
  891. #endif
  892. }
  893. }
  894. g_strfreev(lines);
  895. return 0;
  896. }