FFmpeg: libavformat/rtmpproto.c Source File

FFmpeg
rtmpproto.c
Go to the documentation of this file.
1 /*
2  * RTMP network protocol
3  * Copyright (c) 2009 Konstantin Shishkov
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * RTMP protocol
25  */
26 
27 #include "libavcodec/bytestream.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/base64.h"
30 #include "libavutil/intfloat.h"
31 #include "libavutil/lfg.h"
32 #include "libavutil/md5.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/random_seed.h"
35 #include "libavutil/sha.h"
36 #include "avformat.h"
37 #include "internal.h"
38 
39 #include "network.h"
40 
41 #include "flv.h"
42 #include "rtmp.h"
43 #include "rtmpcrypt.h"
44 #include "rtmppkt.h"
45 #include "url.h"
46 
47 #if CONFIG_ZLIB
48 #include <zlib.h>
49 #endif
50 
51  #define APP_MAX_LENGTH 1024
52  #define PLAYPATH_MAX_LENGTH 256
53  #define TCURL_MAX_LENGTH 512
54  #define FLASHVER_MAX_LENGTH 64
55  #define RTMP_PKTDATA_DEFAULT_SIZE 4096
56  #define RTMP_HEADER 11
57 
58 /** RTMP protocol handler state */
59  typedef enum {
60   STATE_START, ///< client has not done anything yet
61   STATE_HANDSHAKED, ///< client has performed handshake
62   STATE_FCPUBLISH, ///< client FCPublishing stream (for output)
63   STATE_PLAYING, ///< client has started receiving multimedia data from server
64   STATE_SEEKING, ///< client has started the seek operation. Back on STATE_PLAYING when the time comes
65   STATE_PUBLISHING, ///< client has started sending multimedia data to server (for output)
66   STATE_RECEIVING, ///< received a publish command (for input)
67   STATE_SENDING, ///< received a play command (for output)
68   STATE_STOPPED, ///< the broadcast has been stopped
69 } ClientState;
70 
71  typedef struct TrackedMethod {
72   char *name;
73   int id;
74 } TrackedMethod;
75 
76 /** protocol handler context */
77  typedef struct RTMPContext {
78   const AVClass *class;
79   URLContext* stream; ///< TCP stream used in interactions with RTMP server
80   RTMPPacket *prev_pkt[2]; ///< packet history used when reading and sending packets ([0] for reading, [1] for writing)
81   int nb_prev_pkt[2]; ///< number of elements in prev_pkt
82   int in_chunk_size; ///< size of the chunks incoming RTMP packets are divided into
83   int out_chunk_size; ///< size of the chunks outgoing RTMP packets are divided into
84   int is_input; ///< input/output flag
85   char *playpath; ///< stream identifier to play (with possible "mp4:" prefix)
86   int live; ///< 0: recorded, -1: live, -2: both
87   char *app; ///< name of application
88   char *conn; ///< append arbitrary AMF data to the Connect message
89   ClientState state; ///< current state
90   int stream_id; ///< ID assigned by the server for the stream
91   uint8_t* flv_data; ///< buffer with data for demuxer
92   int flv_size; ///< current buffer size
93   int flv_off; ///< number of bytes read from current buffer
94   int flv_nb_packets; ///< number of flv packets published
95   RTMPPacket out_pkt; ///< rtmp packet, created from flv a/v or metadata (for output)
96   uint32_t client_report_size; ///< number of bytes after which client should report to server
97   uint32_t bytes_read; ///< number of bytes read from server
98   uint32_t last_bytes_read; ///< number of bytes read last reported to server
99   int skip_bytes; ///< number of bytes to skip from the input FLV stream in the next write call
100   uint8_t flv_header[RTMP_HEADER]; ///< partial incoming flv packet header
101   int flv_header_bytes; ///< number of initialized bytes in flv_header
102   int nb_invokes; ///< keeps track of invoke messages
103   char* tcurl; ///< url of the target stream
104   char* flashver; ///< version of the flash plugin
105   char* swfhash; ///< SHA256 hash of the decompressed SWF file (32 bytes)
106   int swfhash_len; ///< length of the SHA256 hash
107   int swfsize; ///< size of the decompressed SWF file
108   char* swfurl; ///< url of the swf player
109   char* swfverify; ///< URL to player swf file, compute hash/size automatically
110   char swfverification[42]; ///< hash of the SWF verification
111   char* pageurl; ///< url of the web page
112   char* subscribe; ///< name of live stream to subscribe
113   int server_bw; ///< server bandwidth
114   int client_buffer_time; ///< client buffer time in ms
115   int flush_interval; ///< number of packets flushed in the same request (RTMPT only)
116   int encrypted; ///< use an encrypted connection (RTMPE only)
117   TrackedMethod*tracked_methods; ///< tracked methods buffer
118   int nb_tracked_methods; ///< number of tracked methods
119   int tracked_methods_size; ///< size of the tracked methods buffer
120   int listen; ///< listen mode flag
121   int listen_timeout; ///< listen timeout to wait for new connections
122   int nb_streamid; ///< The next stream id to return on createStream calls
123   char username[50];
124   char password[50];
125   char auth_params[500];
126   int do_reconnect;
127   int auth_tried;
128 } RTMPContext;
129 
130  #define PLAYER_KEY_OPEN_PART_LEN 30 ///< length of partial key used for first client digest signing
131 /** Client key used for digest signing */
132  static const uint8_t rtmp_player_key[] = {
133  'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
134  'F', 'l', 'a', 's', 'h', ' ', 'P', 'l', 'a', 'y', 'e', 'r', ' ', '0', '0', '1',
135 
136  0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
137  0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
138  0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
139 };
140 
141  #define SERVER_KEY_OPEN_PART_LEN 36 ///< length of partial key used for first server digest signing
142 /** Key used for RTMP server digest signing */
143  static const uint8_t rtmp_server_key[] = {
144  'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
145  'F', 'l', 'a', 's', 'h', ' ', 'M', 'e', 'd', 'i', 'a', ' ',
146  'S', 'e', 'r', 'v', 'e', 'r', ' ', '0', '0', '1',
147 
148  0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
149  0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
150  0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
151 };
152 
153  static int add_tracked_method(RTMPContext *rt, const char *name, int id)
154 {
155  int err;
156 
157  if (rt->nb_tracked_methods + 1 > rt->tracked_methods_size) {
158  rt->tracked_methods_size = (rt->nb_tracked_methods + 1) * 2;
159  if ((err = av_reallocp(&rt->tracked_methods, rt->tracked_methods_size *
160  sizeof(*rt->tracked_methods))) < 0) {
161  rt->nb_tracked_methods = 0;
162  rt->tracked_methods_size = 0;
163  return err;
164  }
165  }
166 
167  rt->tracked_methods[rt->nb_tracked_methods].name = av_strdup(name);
168  if (!rt->tracked_methods[rt->nb_tracked_methods].name)
169  return AVERROR(ENOMEM);
170  rt->tracked_methods[rt->nb_tracked_methods].id = id;
171  rt->nb_tracked_methods++;
172 
173  return 0;
174 }
175 
176  static void del_tracked_method(RTMPContext *rt, int index)
177 {
178  memmove(&rt->tracked_methods[index], &rt->tracked_methods[index + 1],
179  sizeof(*rt->tracked_methods) * (rt->nb_tracked_methods - index - 1));
180  rt->nb_tracked_methods--;
181 }
182 
183  static int find_tracked_method(URLContext *s, RTMPPacket *pkt, int offset,
184  char **tracked_method)
185 {
186  RTMPContext *rt = s->priv_data;
187  GetByteContext gbc;
188  double pkt_id;
189  int ret;
190  int i;
191 
192  bytestream2_init(&gbc, pkt->data + offset, pkt->size - offset);
193  if ((ret = ff_amf_read_number(&gbc, &pkt_id)) < 0)
194  return ret;
195 
196  for (i = 0; i < rt->nb_tracked_methods; i++) {
197  if (rt->tracked_methods[i].id != pkt_id)
198  continue;
199 
200  *tracked_method = rt->tracked_methods[i].name;
201  del_tracked_method(rt, i);
202  break;
203  }
204 
205  return 0;
206 }
207 
208  static void free_tracked_methods(RTMPContext *rt)
209 {
210  int i;
211 
212  for (i = 0; i < rt->nb_tracked_methods; i ++)
213  av_free(rt->tracked_methods[i].name);
214  av_free(rt->tracked_methods);
215  rt->tracked_methods = NULL;
216  rt->tracked_methods_size = 0;
217  rt->nb_tracked_methods = 0;
218 }
219 
220  static int rtmp_send_packet(RTMPContext *rt, RTMPPacket *pkt, int track)
221 {
222  int ret;
223 
224  if (pkt->type == RTMP_PT_INVOKE && track) {
225  GetByteContext gbc;
226  char name[128];
227  double pkt_id;
228  int len;
229 
230  bytestream2_init(&gbc, pkt->data, pkt->size);
231  if ((ret = ff_amf_read_string(&gbc, name, sizeof(name), &len)) < 0)
232  goto fail;
233 
234  if ((ret = ff_amf_read_number(&gbc, &pkt_id)) < 0)
235  goto fail;
236 
237  if ((ret = add_tracked_method(rt, name, pkt_id)) < 0)
238  goto fail;
239  }
240 
241  ret = ff_rtmp_packet_write(rt->stream, pkt, rt->out_chunk_size,
242  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
243 fail:
244  ff_rtmp_packet_destroy(pkt);
245  return ret;
246 }
247 
248  static int rtmp_write_amf_data(URLContext *s, char *param, uint8_t **p)
249 {
250  char *field, *value;
251  char type;
252 
253  /* The type must be B for Boolean, N for number, S for string, O for
254  * object, or Z for null. For Booleans the data must be either 0 or 1 for
255  * FALSE or TRUE, respectively. Likewise for Objects the data must be
256  * 0 or 1 to end or begin an object, respectively. Data items in subobjects
257  * may be named, by prefixing the type with 'N' and specifying the name
258  * before the value (ie. NB:myFlag:1). This option may be used multiple times
259  * to construct arbitrary AMF sequences. */
260  if (param[0] && param[1] == ':') {
261  type = param[0];
262  value = param + 2;
263  } else if (param[0] == 'N' && param[1] && param[2] == ':') {
264  type = param[1];
265  field = param + 3;
266  value = strchr(field, ':');
267  if (!value)
268  goto fail;
269  *value = '0円';
270  value++;
271 
272  ff_amf_write_field_name(p, field);
273  } else {
274  goto fail;
275  }
276 
277  switch (type) {
278  case 'B':
279  ff_amf_write_bool(p, value[0] != '0');
280  break;
281  case 'S':
282  ff_amf_write_string(p, value);
283  break;
284  case 'N':
285  ff_amf_write_number(p, strtod(value, NULL));
286  break;
287  case 'Z':
288  ff_amf_write_null(p);
289  break;
290  case 'O':
291  if (value[0] != '0')
292  ff_amf_write_object_start(p);
293  else
294  ff_amf_write_object_end(p);
295  break;
296  default:
297  goto fail;
298  break;
299  }
300 
301  return 0;
302 
303 fail:
304  av_log(s, AV_LOG_ERROR, "Invalid AMF parameter: %s\n", param);
305  return AVERROR(EINVAL);
306 }
307 
308 /**
309  * Generate 'connect' call and send it to the server.
310  */
311  static int gen_connect(URLContext *s, RTMPContext *rt)
312 {
313  RTMPPacket pkt;
314  uint8_t *p;
315  int ret;
316 
317  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
318  0, 4096 + APP_MAX_LENGTH)) < 0)
319  return ret;
320 
321  p = pkt.data;
322 
323  ff_amf_write_string(&p, "connect");
324  ff_amf_write_number(&p, ++rt->nb_invokes);
325  ff_amf_write_object_start(&p);
326  ff_amf_write_field_name(&p, "app");
327  ff_amf_write_string2(&p, rt->app, rt->auth_params);
328 
329  if (!rt->is_input) {
330  ff_amf_write_field_name(&p, "type");
331  ff_amf_write_string(&p, "nonprivate");
332  }
333  ff_amf_write_field_name(&p, "flashVer");
334  ff_amf_write_string(&p, rt->flashver);
335 
336  if (rt->swfurl) {
337  ff_amf_write_field_name(&p, "swfUrl");
338  ff_amf_write_string(&p, rt->swfurl);
339  }
340 
341  ff_amf_write_field_name(&p, "tcUrl");
342  ff_amf_write_string2(&p, rt->tcurl, rt->auth_params);
343  if (rt->is_input) {
344  ff_amf_write_field_name(&p, "fpad");
345  ff_amf_write_bool(&p, 0);
346  ff_amf_write_field_name(&p, "capabilities");
347  ff_amf_write_number(&p, 15.0);
348 
349  /* Tell the server we support all the audio codecs except
350  * SUPPORT_SND_INTEL (0x0008) and SUPPORT_SND_UNUSED (0x0010)
351  * which are unused in the RTMP protocol implementation. */
352  ff_amf_write_field_name(&p, "audioCodecs");
353  ff_amf_write_number(&p, 4071.0);
354  ff_amf_write_field_name(&p, "videoCodecs");
355  ff_amf_write_number(&p, 252.0);
356  ff_amf_write_field_name(&p, "videoFunction");
357  ff_amf_write_number(&p, 1.0);
358 
359  if (rt->pageurl) {
360  ff_amf_write_field_name(&p, "pageUrl");
361  ff_amf_write_string(&p, rt->pageurl);
362  }
363  }
364  ff_amf_write_object_end(&p);
365 
366  if (rt->conn) {
367  char *param = rt->conn;
368 
369  // Write arbitrary AMF data to the Connect message.
370  while (param != NULL) {
371  char *sep;
372  param += strspn(param, " ");
373  if (!*param)
374  break;
375  sep = strchr(param, ' ');
376  if (sep)
377  *sep = '0円';
378  if ((ret = rtmp_write_amf_data(s, param, &p)) < 0) {
379  // Invalid AMF parameter.
380  ff_rtmp_packet_destroy(&pkt);
381  return ret;
382  }
383 
384  if (sep)
385  param = sep + 1;
386  else
387  break;
388  }
389  }
390 
391  pkt.size = p - pkt.data;
392 
393  return rtmp_send_packet(rt, &pkt, 1);
394 }
395 
396  static int read_connect(URLContext *s, RTMPContext *rt)
397 {
398  RTMPPacket pkt = { 0 };
399  uint8_t *p;
400  const uint8_t *cp;
401  int ret;
402  char command[64];
403  int stringlen;
404  double seqnum;
405  uint8_t tmpstr[256];
406  GetByteContext gbc;
407 
408  if ((ret = ff_rtmp_packet_read(rt->stream, &pkt, rt->in_chunk_size,
409  &rt->prev_pkt[0], &rt->nb_prev_pkt[0])) < 0)
410  return ret;
411  cp = pkt.data;
412  bytestream2_init(&gbc, cp, pkt.size);
413  if (ff_amf_read_string(&gbc, command, sizeof(command), &stringlen)) {
414  av_log(s, AV_LOG_ERROR, "Unable to read command string\n");
415  ff_rtmp_packet_destroy(&pkt);
416  return AVERROR_INVALIDDATA;
417  }
418  if (strcmp(command, "connect")) {
419  av_log(s, AV_LOG_ERROR, "Expecting connect, got %s\n", command);
420  ff_rtmp_packet_destroy(&pkt);
421  return AVERROR_INVALIDDATA;
422  }
423  ret = ff_amf_read_number(&gbc, &seqnum);
424  if (ret)
425  av_log(s, AV_LOG_WARNING, "SeqNum not found\n");
426  /* Here one could parse an AMF Object with data as flashVers and others. */
427  ret = ff_amf_get_field_value(gbc.buffer,
428  gbc.buffer + bytestream2_get_bytes_left(&gbc),
429  "app", tmpstr, sizeof(tmpstr));
430  if (ret)
431  av_log(s, AV_LOG_WARNING, "App field not found in connect\n");
432  if (!ret && strcmp(tmpstr, rt->app))
433  av_log(s, AV_LOG_WARNING, "App field don't match up: %s <-> %s\n",
434  tmpstr, rt->app);
435  ff_rtmp_packet_destroy(&pkt);
436 
437  // Send Window Acknowledgement Size (as defined in speficication)
438  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
439  RTMP_PT_SERVER_BW, 0, 4)) < 0)
440  return ret;
441  p = pkt.data;
442  bytestream_put_be32(&p, rt->server_bw);
443  pkt.size = p - pkt.data;
444  ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
445  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
446  ff_rtmp_packet_destroy(&pkt);
447  if (ret < 0)
448  return ret;
449  // Send Peer Bandwidth
450  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
451  RTMP_PT_CLIENT_BW, 0, 5)) < 0)
452  return ret;
453  p = pkt.data;
454  bytestream_put_be32(&p, rt->server_bw);
455  bytestream_put_byte(&p, 2); // dynamic
456  pkt.size = p - pkt.data;
457  ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
458  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
459  ff_rtmp_packet_destroy(&pkt);
460  if (ret < 0)
461  return ret;
462 
463  // Ping request
464  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
465  RTMP_PT_PING, 0, 6)) < 0)
466  return ret;
467 
468  p = pkt.data;
469  bytestream_put_be16(&p, 0); // 0 -> Stream Begin
470  bytestream_put_be32(&p, 0);
471  ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
472  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
473  ff_rtmp_packet_destroy(&pkt);
474  if (ret < 0)
475  return ret;
476 
477  // Chunk size
478  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
479  RTMP_PT_CHUNK_SIZE, 0, 4)) < 0)
480  return ret;
481 
482  p = pkt.data;
483  bytestream_put_be32(&p, rt->out_chunk_size);
484  ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
485  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
486  ff_rtmp_packet_destroy(&pkt);
487  if (ret < 0)
488  return ret;
489 
490  // Send result_ NetConnection.Connect.Success to connect
491  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
492  RTMP_PT_INVOKE, 0,
493  RTMP_PKTDATA_DEFAULT_SIZE)) < 0)
494  return ret;
495 
496  p = pkt.data;
497  ff_amf_write_string(&p, "_result");
498  ff_amf_write_number(&p, seqnum);
499 
500  ff_amf_write_object_start(&p);
501  ff_amf_write_field_name(&p, "fmsVer");
502  ff_amf_write_string(&p, "FMS/3,0,1,123");
503  ff_amf_write_field_name(&p, "capabilities");
504  ff_amf_write_number(&p, 31);
505  ff_amf_write_object_end(&p);
506 
507  ff_amf_write_object_start(&p);
508  ff_amf_write_field_name(&p, "level");
509  ff_amf_write_string(&p, "status");
510  ff_amf_write_field_name(&p, "code");
511  ff_amf_write_string(&p, "NetConnection.Connect.Success");
512  ff_amf_write_field_name(&p, "description");
513  ff_amf_write_string(&p, "Connection succeeded.");
514  ff_amf_write_field_name(&p, "objectEncoding");
515  ff_amf_write_number(&p, 0);
516  ff_amf_write_object_end(&p);
517 
518  pkt.size = p - pkt.data;
519  ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
520  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
521  ff_rtmp_packet_destroy(&pkt);
522  if (ret < 0)
523  return ret;
524 
525  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
526  RTMP_PT_INVOKE, 0, 30)) < 0)
527  return ret;
528  p = pkt.data;
529  ff_amf_write_string(&p, "onBWDone");
530  ff_amf_write_number(&p, 0);
531  ff_amf_write_null(&p);
532  ff_amf_write_number(&p, 8192);
533  pkt.size = p - pkt.data;
534  ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
535  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
536  ff_rtmp_packet_destroy(&pkt);
537 
538  return ret;
539 }
540 
541 /**
542  * Generate 'releaseStream' call and send it to the server. It should make
543  * the server release some channel for media streams.
544  */
545  static int gen_release_stream(URLContext *s, RTMPContext *rt)
546 {
547  RTMPPacket pkt;
548  uint8_t *p;
549  int ret;
550 
551  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
552  0, 29 + strlen(rt->playpath))) < 0)
553  return ret;
554 
555  av_log(s, AV_LOG_DEBUG, "Releasing stream...\n");
556  p = pkt.data;
557  ff_amf_write_string(&p, "releaseStream");
558  ff_amf_write_number(&p, ++rt->nb_invokes);
559  ff_amf_write_null(&p);
560  ff_amf_write_string(&p, rt->playpath);
561 
562  return rtmp_send_packet(rt, &pkt, 1);
563 }
564 
565 /**
566  * Generate 'FCPublish' call and send it to the server. It should make
567  * the server preapare for receiving media streams.
568  */
569  static int gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
570 {
571  RTMPPacket pkt;
572  uint8_t *p;
573  int ret;
574 
575  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
576  0, 25 + strlen(rt->playpath))) < 0)
577  return ret;
578 
579  av_log(s, AV_LOG_DEBUG, "FCPublish stream...\n");
580  p = pkt.data;
581  ff_amf_write_string(&p, "FCPublish");
582  ff_amf_write_number(&p, ++rt->nb_invokes);
583  ff_amf_write_null(&p);
584  ff_amf_write_string(&p, rt->playpath);
585 
586  return rtmp_send_packet(rt, &pkt, 1);
587 }
588 
589 /**
590  * Generate 'FCUnpublish' call and send it to the server. It should make
591  * the server destroy stream.
592  */
593  static int gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
594 {
595  RTMPPacket pkt;
596  uint8_t *p;
597  int ret;
598 
599  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
600  0, 27 + strlen(rt->playpath))) < 0)
601  return ret;
602 
603  av_log(s, AV_LOG_DEBUG, "UnPublishing stream...\n");
604  p = pkt.data;
605  ff_amf_write_string(&p, "FCUnpublish");
606  ff_amf_write_number(&p, ++rt->nb_invokes);
607  ff_amf_write_null(&p);
608  ff_amf_write_string(&p, rt->playpath);
609 
610  return rtmp_send_packet(rt, &pkt, 0);
611 }
612 
613 /**
614  * Generate 'createStream' call and send it to the server. It should make
615  * the server allocate some channel for media streams.
616  */
617  static int gen_create_stream(URLContext *s, RTMPContext *rt)
618 {
619  RTMPPacket pkt;
620  uint8_t *p;
621  int ret;
622 
623  av_log(s, AV_LOG_DEBUG, "Creating stream...\n");
624 
625  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
626  0, 25)) < 0)
627  return ret;
628 
629  p = pkt.data;
630  ff_amf_write_string(&p, "createStream");
631  ff_amf_write_number(&p, ++rt->nb_invokes);
632  ff_amf_write_null(&p);
633 
634  return rtmp_send_packet(rt, &pkt, 1);
635 }
636 
637 
638 /**
639  * Generate 'deleteStream' call and send it to the server. It should make
640  * the server remove some channel for media streams.
641  */
642  static int gen_delete_stream(URLContext *s, RTMPContext *rt)
643 {
644  RTMPPacket pkt;
645  uint8_t *p;
646  int ret;
647 
648  av_log(s, AV_LOG_DEBUG, "Deleting stream...\n");
649 
650  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
651  0, 34)) < 0)
652  return ret;
653 
654  p = pkt.data;
655  ff_amf_write_string(&p, "deleteStream");
656  ff_amf_write_number(&p, ++rt->nb_invokes);
657  ff_amf_write_null(&p);
658  ff_amf_write_number(&p, rt->stream_id);
659 
660  return rtmp_send_packet(rt, &pkt, 0);
661 }
662 
663 /**
664  * Generate client buffer time and send it to the server.
665  */
666  static int gen_buffer_time(URLContext *s, RTMPContext *rt)
667 {
668  RTMPPacket pkt;
669  uint8_t *p;
670  int ret;
671 
672  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
673  1, 10)) < 0)
674  return ret;
675 
676  p = pkt.data;
677  bytestream_put_be16(&p, 3);
678  bytestream_put_be32(&p, rt->stream_id);
679  bytestream_put_be32(&p, rt->client_buffer_time);
680 
681  return rtmp_send_packet(rt, &pkt, 0);
682 }
683 
684 /**
685  * Generate 'play' call and send it to the server, then ping the server
686  * to start actual playing.
687  */
688  static int gen_play(URLContext *s, RTMPContext *rt)
689 {
690  RTMPPacket pkt;
691  uint8_t *p;
692  int ret;
693 
694  av_log(s, AV_LOG_DEBUG, "Sending play command for '%s'\n", rt->playpath);
695 
696  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SOURCE_CHANNEL, RTMP_PT_INVOKE,
697  0, 29 + strlen(rt->playpath))) < 0)
698  return ret;
699 
700  pkt.extra = rt->stream_id;
701 
702  p = pkt.data;
703  ff_amf_write_string(&p, "play");
704  ff_amf_write_number(&p, ++rt->nb_invokes);
705  ff_amf_write_null(&p);
706  ff_amf_write_string(&p, rt->playpath);
707  ff_amf_write_number(&p, rt->live * 1000);
708 
709  return rtmp_send_packet(rt, &pkt, 1);
710 }
711 
712  static int gen_seek(URLContext *s, RTMPContext *rt, int64_t timestamp)
713 {
714  RTMPPacket pkt;
715  uint8_t *p;
716  int ret;
717 
718  av_log(s, AV_LOG_DEBUG, "Sending seek command for timestamp %"PRId64"\n",
719  timestamp);
720 
721  if ((ret = ff_rtmp_packet_create(&pkt, 3, RTMP_PT_INVOKE, 0, 26)) < 0)
722  return ret;
723 
724  pkt.extra = rt->stream_id;
725 
726  p = pkt.data;
727  ff_amf_write_string(&p, "seek");
728  ff_amf_write_number(&p, 0); //no tracking back responses
729  ff_amf_write_null(&p); //as usual, the first null param
730  ff_amf_write_number(&p, timestamp); //where we want to jump
731 
732  return rtmp_send_packet(rt, &pkt, 1);
733 }
734 
735 /**
736  * Generate 'publish' call and send it to the server.
737  */
738  static int gen_publish(URLContext *s, RTMPContext *rt)
739 {
740  RTMPPacket pkt;
741  uint8_t *p;
742  int ret;
743 
744  av_log(s, AV_LOG_DEBUG, "Sending publish command for '%s'\n", rt->playpath);
745 
746  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SOURCE_CHANNEL, RTMP_PT_INVOKE,
747  0, 30 + strlen(rt->playpath))) < 0)
748  return ret;
749 
750  pkt.extra = rt->stream_id;
751 
752  p = pkt.data;
753  ff_amf_write_string(&p, "publish");
754  ff_amf_write_number(&p, ++rt->nb_invokes);
755  ff_amf_write_null(&p);
756  ff_amf_write_string(&p, rt->playpath);
757  ff_amf_write_string(&p, "live");
758 
759  return rtmp_send_packet(rt, &pkt, 1);
760 }
761 
762 /**
763  * Generate ping reply and send it to the server.
764  */
765  static int gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
766 {
767  RTMPPacket pkt;
768  uint8_t *p;
769  int ret;
770 
771  if (ppkt->size < 6) {
772  av_log(s, AV_LOG_ERROR, "Too short ping packet (%d)\n",
773  ppkt->size);
774  return AVERROR_INVALIDDATA;
775  }
776 
777  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
778  ppkt->timestamp + 1, 6)) < 0)
779  return ret;
780 
781  p = pkt.data;
782  bytestream_put_be16(&p, 7);
783  bytestream_put_be32(&p, AV_RB32(ppkt->data+2));
784 
785  return rtmp_send_packet(rt, &pkt, 0);
786 }
787 
788 /**
789  * Generate SWF verification message and send it to the server.
790  */
791  static int gen_swf_verification(URLContext *s, RTMPContext *rt)
792 {
793  RTMPPacket pkt;
794  uint8_t *p;
795  int ret;
796 
797  av_log(s, AV_LOG_DEBUG, "Sending SWF verification...\n");
798  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
799  0, 44)) < 0)
800  return ret;
801 
802  p = pkt.data;
803  bytestream_put_be16(&p, 27);
804  memcpy(p, rt->swfverification, 42);
805 
806  return rtmp_send_packet(rt, &pkt, 0);
807 }
808 
809 /**
810  * Generate server bandwidth message and send it to the server.
811  */
812  static int gen_server_bw(URLContext *s, RTMPContext *rt)
813 {
814  RTMPPacket pkt;
815  uint8_t *p;
816  int ret;
817 
818  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_SERVER_BW,
819  0, 4)) < 0)
820  return ret;
821 
822  p = pkt.data;
823  bytestream_put_be32(&p, rt->server_bw);
824 
825  return rtmp_send_packet(rt, &pkt, 0);
826 }
827 
828 /**
829  * Generate check bandwidth message and send it to the server.
830  */
831  static int gen_check_bw(URLContext *s, RTMPContext *rt)
832 {
833  RTMPPacket pkt;
834  uint8_t *p;
835  int ret;
836 
837  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
838  0, 21)) < 0)
839  return ret;
840 
841  p = pkt.data;
842  ff_amf_write_string(&p, "_checkbw");
843  ff_amf_write_number(&p, ++rt->nb_invokes);
844  ff_amf_write_null(&p);
845 
846  return rtmp_send_packet(rt, &pkt, 1);
847 }
848 
849 /**
850  * Generate report on bytes read so far and send it to the server.
851  */
852  static int gen_bytes_read(URLContext *s, RTMPContext *rt, uint32_t ts)
853 {
854  RTMPPacket pkt;
855  uint8_t *p;
856  int ret;
857 
858  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_BYTES_READ,
859  ts, 4)) < 0)
860  return ret;
861 
862  p = pkt.data;
863  bytestream_put_be32(&p, rt->bytes_read);
864 
865  return rtmp_send_packet(rt, &pkt, 0);
866 }
867 
868  static int gen_fcsubscribe_stream(URLContext *s, RTMPContext *rt,
869  const char *subscribe)
870 {
871  RTMPPacket pkt;
872  uint8_t *p;
873  int ret;
874 
875  if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
876  0, 27 + strlen(subscribe))) < 0)
877  return ret;
878 
879  p = pkt.data;
880  ff_amf_write_string(&p, "FCSubscribe");
881  ff_amf_write_number(&p, ++rt->nb_invokes);
882  ff_amf_write_null(&p);
883  ff_amf_write_string(&p, subscribe);
884 
885  return rtmp_send_packet(rt, &pkt, 1);
886 }
887 
888  int ff_rtmp_calc_digest(const uint8_t *src, int len, int gap,
889  const uint8_t *key, int keylen, uint8_t *dst)
890 {
891  struct AVSHA *sha;
892  uint8_t hmac_buf[64+32] = {0};
893  int i;
894 
895  sha = av_sha_alloc();
896  if (!sha)
897  return AVERROR(ENOMEM);
898 
899  if (keylen < 64) {
900  memcpy(hmac_buf, key, keylen);
901  } else {
902  av_sha_init(sha, 256);
903  av_sha_update(sha,key, keylen);
904  av_sha_final(sha, hmac_buf);
905  }
906  for (i = 0; i < 64; i++)
907  hmac_buf[i] ^= HMAC_IPAD_VAL;
908 
909  av_sha_init(sha, 256);
910  av_sha_update(sha, hmac_buf, 64);
911  if (gap <= 0) {
912  av_sha_update(sha, src, len);
913  } else { //skip 32 bytes used for storing digest
914  av_sha_update(sha, src, gap);
915  av_sha_update(sha, src + gap + 32, len - gap - 32);
916  }
917  av_sha_final(sha, hmac_buf + 64);
918 
919  for (i = 0; i < 64; i++)
920  hmac_buf[i] ^= HMAC_IPAD_VAL ^ HMAC_OPAD_VAL; //reuse XORed key for opad
921  av_sha_init(sha, 256);
922  av_sha_update(sha, hmac_buf, 64+32);
923  av_sha_final(sha, dst);
924 
925  av_free(sha);
926 
927  return 0;
928 }
929 
930  int ff_rtmp_calc_digest_pos(const uint8_t *buf, int off, int mod_val,
931  int add_val)
932 {
933  int i, digest_pos = 0;
934 
935  for (i = 0; i < 4; i++)
936  digest_pos += buf[i + off];
937  digest_pos = digest_pos % mod_val + add_val;
938 
939  return digest_pos;
940 }
941 
942 /**
943  * Put HMAC-SHA2 digest of packet data (except for the bytes where this digest
944  * will be stored) into that packet.
945  *
946  * @param buf handshake data (1536 bytes)
947  * @param encrypted use an encrypted connection (RTMPE)
948  * @return offset to the digest inside input data
949  */
950  static int rtmp_handshake_imprint_with_digest(uint8_t *buf, int encrypted)
951 {
952  int ret, digest_pos;
953 
954  if (encrypted)
955  digest_pos = ff_rtmp_calc_digest_pos(buf, 772, 728, 776);
956  else
957  digest_pos = ff_rtmp_calc_digest_pos(buf, 8, 728, 12);
958 
959  ret = ff_rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
960  rtmp_player_key, PLAYER_KEY_OPEN_PART_LEN,
961  buf + digest_pos);
962  if (ret < 0)
963  return ret;
964 
965  return digest_pos;
966 }
967 
968 /**
969  * Verify that the received server response has the expected digest value.
970  *
971  * @param buf handshake data received from the server (1536 bytes)
972  * @param off position to search digest offset from
973  * @return 0 if digest is valid, digest position otherwise
974  */
975  static int rtmp_validate_digest(uint8_t *buf, int off)
976 {
977  uint8_t digest[32];
978  int ret, digest_pos;
979 
980  digest_pos = ff_rtmp_calc_digest_pos(buf, off, 728, off + 4);
981 
982  ret = ff_rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
983  rtmp_server_key, SERVER_KEY_OPEN_PART_LEN,
984  digest);
985  if (ret < 0)
986  return ret;
987 
988  if (!memcmp(digest, buf + digest_pos, 32))
989  return digest_pos;
990  return 0;
991 }
992 
993  static int rtmp_calc_swf_verification(URLContext *s, RTMPContext *rt,
994  uint8_t *buf)
995 {
996  uint8_t *p;
997  int ret;
998 
999  if (rt->swfhash_len != 32) {
1000  av_log(s, AV_LOG_ERROR,
1001  "Hash of the decompressed SWF file is not 32 bytes long.\n");
1002  return AVERROR(EINVAL);
1003  }
1004 
1005  p = &rt->swfverification[0];
1006  bytestream_put_byte(&p, 1);
1007  bytestream_put_byte(&p, 1);
1008  bytestream_put_be32(&p, rt->swfsize);
1009  bytestream_put_be32(&p, rt->swfsize);
1010 
1011  if ((ret = ff_rtmp_calc_digest(rt->swfhash, 32, 0, buf, 32, p)) < 0)
1012  return ret;
1013 
1014  return 0;
1015 }
1016 
1017 #if CONFIG_ZLIB
1018 static int rtmp_uncompress_swfplayer(uint8_t *in_data, int64_t in_size,
1019  uint8_t **out_data, int64_t *out_size)
1020 {
1021  z_stream zs = { 0 };
1022  void *ptr;
1023  int size;
1024  int ret = 0;
1025 
1026  zs.avail_in = in_size;
1027  zs.next_in = in_data;
1028  ret = inflateInit(&zs);
1029  if (ret != Z_OK)
1030  return AVERROR_UNKNOWN;
1031 
1032  do {
1033  uint8_t tmp_buf[16384];
1034 
1035  zs.avail_out = sizeof(tmp_buf);
1036  zs.next_out = tmp_buf;
1037 
1038  ret = inflate(&zs, Z_NO_FLUSH);
1039  if (ret != Z_OK && ret != Z_STREAM_END) {
1040  ret = AVERROR_UNKNOWN;
1041  goto fail;
1042  }
1043 
1044  size = sizeof(tmp_buf) - zs.avail_out;
1045  if (!(ptr = av_realloc(*out_data, *out_size + size))) {
1046  ret = AVERROR(ENOMEM);
1047  goto fail;
1048  }
1049  *out_data = ptr;
1050 
1051  memcpy(*out_data + *out_size, tmp_buf, size);
1052  *out_size += size;
1053  } while (zs.avail_out == 0);
1054 
1055 fail:
1056  inflateEnd(&zs);
1057  return ret;
1058 }
1059 #endif
1060 
1061  static int rtmp_calc_swfhash(URLContext *s)
1062 {
1063  RTMPContext *rt = s->priv_data;
1064  uint8_t *in_data = NULL, *out_data = NULL, *swfdata;
1065  int64_t in_size, out_size;
1066  URLContext *stream;
1067  char swfhash[32];
1068  int swfsize;
1069  int ret = 0;
1070 
1071  /* Get the SWF player file. */
1072  if ((ret = ffurl_open(&stream, rt->swfverify, AVIO_FLAG_READ,
1073  &s->interrupt_callback, NULL)) < 0) {
1074  av_log(s, AV_LOG_ERROR, "Cannot open connection %s.\n", rt->swfverify);
1075  goto fail;
1076  }
1077 
1078  if ((in_size = ffurl_seek(stream, 0, AVSEEK_SIZE)) < 0) {
1079  ret = AVERROR(EIO);
1080  goto fail;
1081  }
1082 
1083  if (!(in_data = av_malloc(in_size))) {
1084  ret = AVERROR(ENOMEM);
1085  goto fail;
1086  }
1087 
1088  if ((ret = ffurl_read_complete(stream, in_data, in_size)) < 0)
1089  goto fail;
1090 
1091  if (in_size < 3) {
1092  ret = AVERROR_INVALIDDATA;
1093  goto fail;
1094  }
1095 
1096  if (!memcmp(in_data, "CWS", 3)) {
1097  /* Decompress the SWF player file using Zlib. */
1098  if (!(out_data = av_malloc(8))) {
1099  ret = AVERROR(ENOMEM);
1100  goto fail;
1101  }
1102  *in_data = 'F'; // magic stuff
1103  memcpy(out_data, in_data, 8);
1104  out_size = 8;
1105 
1106 #if CONFIG_ZLIB
1107  if ((ret = rtmp_uncompress_swfplayer(in_data + 8, in_size - 8,
1108  &out_data, &out_size)) < 0)
1109  goto fail;
1110 #else
1111  av_log(s, AV_LOG_ERROR,
1112  "Zlib is required for decompressing the SWF player file.\n");
1113  ret = AVERROR(EINVAL);
1114  goto fail;
1115 #endif
1116  swfsize = out_size;
1117  swfdata = out_data;
1118  } else {
1119  swfsize = in_size;
1120  swfdata = in_data;
1121  }
1122 
1123  /* Compute the SHA256 hash of the SWF player file. */
1124  if ((ret = ff_rtmp_calc_digest(swfdata, swfsize, 0,
1125  "Genuine Adobe Flash Player 001", 30,
1126  swfhash)) < 0)
1127  goto fail;
1128 
1129  /* Set SWFVerification parameters. */
1130  av_opt_set_bin(rt, "rtmp_swfhash", swfhash, 32, 0);
1131  rt->swfsize = swfsize;
1132 
1133 fail:
1134  av_freep(&in_data);
1135  av_freep(&out_data);
1136  ffurl_close(stream);
1137  return ret;
1138 }
1139 
1140 /**
1141  * Perform handshake with the server by means of exchanging pseudorandom data
1142  * signed with HMAC-SHA2 digest.
1143  *
1144  * @return 0 if handshake succeeds, negative value otherwise
1145  */
1146  static int rtmp_handshake(URLContext *s, RTMPContext *rt)
1147 {
1148  AVLFG rnd;
1149  uint8_t tosend [RTMP_HANDSHAKE_PACKET_SIZE+1] = {
1150  3, // unencrypted data
1151  0, 0, 0, 0, // client uptime
1152  RTMP_CLIENT_VER1,
1153  RTMP_CLIENT_VER2,
1154  RTMP_CLIENT_VER3,
1155  RTMP_CLIENT_VER4,
1156  };
1157  uint8_t clientdata[RTMP_HANDSHAKE_PACKET_SIZE];
1158  uint8_t serverdata[RTMP_HANDSHAKE_PACKET_SIZE+1];
1159  int i;
1160  int server_pos, client_pos;
1161  uint8_t digest[32], signature[32];
1162  int ret, type = 0;
1163 
1164  av_log(s, AV_LOG_DEBUG, "Handshaking...\n");
1165 
1166  av_lfg_init(&rnd, 0xDEADC0DE);
1167  // generate handshake packet - 1536 bytes of pseudorandom data
1168  for (i = 9; i <= RTMP_HANDSHAKE_PACKET_SIZE; i++)
1169  tosend[i] = av_lfg_get(&rnd) >> 24;
1170 
1171  if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1172  /* When the client wants to use RTMPE, we have to change the command
1173  * byte to 0x06 which means to use encrypted data and we have to set
1174  * the flash version to at least 9.0.115.0. */
1175  tosend[0] = 6;
1176  tosend[5] = 128;
1177  tosend[6] = 0;
1178  tosend[7] = 3;
1179  tosend[8] = 2;
1180 
1181  /* Initialize the Diffie-Hellmann context and generate the public key
1182  * to send to the server. */
1183  if ((ret = ff_rtmpe_gen_pub_key(rt->stream, tosend + 1)) < 0)
1184  return ret;
1185  }
1186 
1187  client_pos = rtmp_handshake_imprint_with_digest(tosend + 1, rt->encrypted);
1188  if (client_pos < 0)
1189  return client_pos;
1190 
1191  if ((ret = ffurl_write(rt->stream, tosend,
1192  RTMP_HANDSHAKE_PACKET_SIZE + 1)) < 0) {
1193  av_log(s, AV_LOG_ERROR, "Cannot write RTMP handshake request\n");
1194  return ret;
1195  }
1196 
1197  if ((ret = ffurl_read_complete(rt->stream, serverdata,
1198  RTMP_HANDSHAKE_PACKET_SIZE + 1)) < 0) {
1199  av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
1200  return ret;
1201  }
1202 
1203  if ((ret = ffurl_read_complete(rt->stream, clientdata,
1204  RTMP_HANDSHAKE_PACKET_SIZE)) < 0) {
1205  av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
1206  return ret;
1207  }
1208 
1209  av_log(s, AV_LOG_DEBUG, "Type answer %d\n", serverdata[0]);
1210  av_log(s, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
1211  serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
1212 
1213  if (rt->is_input && serverdata[5] >= 3) {
1214  server_pos = rtmp_validate_digest(serverdata + 1, 772);
1215  if (server_pos < 0)
1216  return server_pos;
1217 
1218  if (!server_pos) {
1219  type = 1;
1220  server_pos = rtmp_validate_digest(serverdata + 1, 8);
1221  if (server_pos < 0)
1222  return server_pos;
1223 
1224  if (!server_pos) {
1225  av_log(s, AV_LOG_ERROR, "Server response validating failed\n");
1226  return AVERROR(EIO);
1227  }
1228  }
1229 
1230  /* Generate SWFVerification token (SHA256 HMAC hash of decompressed SWF,
1231  * key are the last 32 bytes of the server handshake. */
1232  if (rt->swfsize) {
1233  if ((ret = rtmp_calc_swf_verification(s, rt, serverdata + 1 +
1234  RTMP_HANDSHAKE_PACKET_SIZE - 32)) < 0)
1235  return ret;
1236  }
1237 
1238  ret = ff_rtmp_calc_digest(tosend + 1 + client_pos, 32, 0,
1239  rtmp_server_key, sizeof(rtmp_server_key),
1240  digest);
1241  if (ret < 0)
1242  return ret;
1243 
1244  ret = ff_rtmp_calc_digest(clientdata, RTMP_HANDSHAKE_PACKET_SIZE - 32,
1245  0, digest, 32, signature);
1246  if (ret < 0)
1247  return ret;
1248 
1249  if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1250  /* Compute the shared secret key sent by the server and initialize
1251  * the RC4 encryption. */
1252  if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
1253  tosend + 1, type)) < 0)
1254  return ret;
1255 
1256  /* Encrypt the signature received by the server. */
1257  ff_rtmpe_encrypt_sig(rt->stream, signature, digest, serverdata[0]);
1258  }
1259 
1260  if (memcmp(signature, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32, 32)) {
1261  av_log(s, AV_LOG_ERROR, "Signature mismatch\n");
1262  return AVERROR(EIO);
1263  }
1264 
1265  for (i = 0; i < RTMP_HANDSHAKE_PACKET_SIZE; i++)
1266  tosend[i] = av_lfg_get(&rnd) >> 24;
1267  ret = ff_rtmp_calc_digest(serverdata + 1 + server_pos, 32, 0,
1268  rtmp_player_key, sizeof(rtmp_player_key),
1269  digest);
1270  if (ret < 0)
1271  return ret;
1272 
1273  ret = ff_rtmp_calc_digest(tosend, RTMP_HANDSHAKE_PACKET_SIZE - 32, 0,
1274  digest, 32,
1275  tosend + RTMP_HANDSHAKE_PACKET_SIZE - 32);
1276  if (ret < 0)
1277  return ret;
1278 
1279  if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1280  /* Encrypt the signature to be send to the server. */
1281  ff_rtmpe_encrypt_sig(rt->stream, tosend +
1282  RTMP_HANDSHAKE_PACKET_SIZE - 32, digest,
1283  serverdata[0]);
1284  }
1285 
1286  // write reply back to the server
1287  if ((ret = ffurl_write(rt->stream, tosend,
1288  RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
1289  return ret;
1290 
1291  if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1292  /* Set RC4 keys for encryption and update the keystreams. */
1293  if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
1294  return ret;
1295  }
1296  } else {
1297  if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1298  /* Compute the shared secret key sent by the server and initialize
1299  * the RC4 encryption. */
1300  if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
1301  tosend + 1, 1)) < 0)
1302  return ret;
1303 
1304  if (serverdata[0] == 9) {
1305  /* Encrypt the signature received by the server. */
1306  ff_rtmpe_encrypt_sig(rt->stream, signature, digest,
1307  serverdata[0]);
1308  }
1309  }
1310 
1311  if ((ret = ffurl_write(rt->stream, serverdata + 1,
1312  RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
1313  return ret;
1314 
1315  if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1316  /* Set RC4 keys for encryption and update the keystreams. */
1317  if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
1318  return ret;
1319  }
1320  }
1321 
1322  return 0;
1323 }
1324 
1325  static int rtmp_receive_hs_packet(RTMPContext* rt, uint32_t *first_int,
1326  uint32_t *second_int, char *arraydata,
1327  int size)
1328 {
1329  int inoutsize;
1330 
1331  inoutsize = ffurl_read_complete(rt->stream, arraydata,
1332  RTMP_HANDSHAKE_PACKET_SIZE);
1333  if (inoutsize <= 0)
1334  return AVERROR(EIO);
1335  if (inoutsize != RTMP_HANDSHAKE_PACKET_SIZE) {
1336  av_log(rt, AV_LOG_ERROR, "Erroneous Message size %d"
1337  " not following standard\n", (int)inoutsize);
1338  return AVERROR(EINVAL);
1339  }
1340 
1341  *first_int = AV_RB32(arraydata);
1342  *second_int = AV_RB32(arraydata + 4);
1343  return 0;
1344 }
1345 
1346  static int rtmp_send_hs_packet(RTMPContext* rt, uint32_t first_int,
1347  uint32_t second_int, char *arraydata, int size)
1348 {
1349  int inoutsize;
1350 
1351  AV_WB32(arraydata, first_int);
1352  AV_WB32(arraydata + 4, second_int);
1353  inoutsize = ffurl_write(rt->stream, arraydata,
1354  RTMP_HANDSHAKE_PACKET_SIZE);
1355  if (inoutsize != RTMP_HANDSHAKE_PACKET_SIZE) {
1356  av_log(rt, AV_LOG_ERROR, "Unable to write answer\n");
1357  return AVERROR(EIO);
1358  }
1359 
1360  return 0;
1361 }
1362 
1363 /**
1364  * rtmp handshake server side
1365  */
1366  static int rtmp_server_handshake(URLContext *s, RTMPContext *rt)
1367 {
1368  uint8_t buffer[RTMP_HANDSHAKE_PACKET_SIZE];
1369  uint32_t hs_epoch;
1370  uint32_t hs_my_epoch;
1371  uint8_t hs_c1[RTMP_HANDSHAKE_PACKET_SIZE];
1372  uint8_t hs_s1[RTMP_HANDSHAKE_PACKET_SIZE];
1373  uint32_t zeroes;
1374  uint32_t temp = 0;
1375  int randomidx = 0;
1376  int inoutsize = 0;
1377  int ret;
1378 
1379  inoutsize = ffurl_read_complete(rt->stream, buffer, 1); // Receive C0
1380  if (inoutsize <= 0) {
1381  av_log(s, AV_LOG_ERROR, "Unable to read handshake\n");
1382  return AVERROR(EIO);
1383  }
1384  // Check Version
1385  if (buffer[0] != 3) {
1386  av_log(s, AV_LOG_ERROR, "RTMP protocol version mismatch\n");
1387  return AVERROR(EIO);
1388  }
1389  if (ffurl_write(rt->stream, buffer, 1) <= 0) { // Send S0
1390  av_log(s, AV_LOG_ERROR,
1391  "Unable to write answer - RTMP S0\n");
1392  return AVERROR(EIO);
1393  }
1394  /* Receive C1 */
1395  ret = rtmp_receive_hs_packet(rt, &hs_epoch, &zeroes, hs_c1,
1396  RTMP_HANDSHAKE_PACKET_SIZE);
1397  if (ret) {
1398  av_log(s, AV_LOG_ERROR, "RTMP Handshake C1 Error\n");
1399  return ret;
1400  }
1401  /* Send S1 */
1402  /* By now same epoch will be sent */
1403  hs_my_epoch = hs_epoch;
1404  /* Generate random */
1405  for (randomidx = 8; randomidx < (RTMP_HANDSHAKE_PACKET_SIZE);
1406  randomidx += 4)
1407  AV_WB32(hs_s1 + randomidx, av_get_random_seed());
1408 
1409  ret = rtmp_send_hs_packet(rt, hs_my_epoch, 0, hs_s1,
1410  RTMP_HANDSHAKE_PACKET_SIZE);
1411  if (ret) {
1412  av_log(s, AV_LOG_ERROR, "RTMP Handshake S1 Error\n");
1413  return ret;
1414  }
1415  /* Send S2 */
1416  ret = rtmp_send_hs_packet(rt, hs_epoch, 0, hs_c1,
1417  RTMP_HANDSHAKE_PACKET_SIZE);
1418  if (ret) {
1419  av_log(s, AV_LOG_ERROR, "RTMP Handshake S2 Error\n");
1420  return ret;
1421  }
1422  /* Receive C2 */
1423  ret = rtmp_receive_hs_packet(rt, &temp, &zeroes, buffer,
1424  RTMP_HANDSHAKE_PACKET_SIZE);
1425  if (ret) {
1426  av_log(s, AV_LOG_ERROR, "RTMP Handshake C2 Error\n");
1427  return ret;
1428  }
1429  if (temp != hs_my_epoch)
1430  av_log(s, AV_LOG_WARNING,
1431  "Erroneous C2 Message epoch does not match up with C1 epoch\n");
1432  if (memcmp(buffer + 8, hs_s1 + 8,
1433  RTMP_HANDSHAKE_PACKET_SIZE - 8))
1434  av_log(s, AV_LOG_WARNING,
1435  "Erroneous C2 Message random does not match up\n");
1436 
1437  return 0;
1438 }
1439 
1440  static int handle_chunk_size(URLContext *s, RTMPPacket *pkt)
1441 {
1442  RTMPContext *rt = s->priv_data;
1443  int ret;
1444 
1445  if (pkt->size < 4) {
1446  av_log(s, AV_LOG_ERROR,
1447  "Too short chunk size change packet (%d)\n",
1448  pkt->size);
1449  return AVERROR_INVALIDDATA;
1450  }
1451 
1452  if (!rt->is_input) {
1453  /* Send the same chunk size change packet back to the server,
1454  * setting the outgoing chunk size to the same as the incoming one. */
1455  if ((ret = ff_rtmp_packet_write(rt->stream, pkt, rt->out_chunk_size,
1456  &rt->prev_pkt[1], &rt->nb_prev_pkt[1])) < 0)
1457  return ret;
1458  rt->out_chunk_size = AV_RB32(pkt->data);
1459  }
1460 
1461  rt->in_chunk_size = AV_RB32(pkt->data);
1462  if (rt->in_chunk_size <= 0) {
1463  av_log(s, AV_LOG_ERROR, "Incorrect chunk size %d\n",
1464  rt->in_chunk_size);
1465  return AVERROR_INVALIDDATA;
1466  }
1467  av_log(s, AV_LOG_DEBUG, "New incoming chunk size = %d\n",
1468  rt->in_chunk_size);
1469 
1470  return 0;
1471 }
1472 
1473  static int handle_ping(URLContext *s, RTMPPacket *pkt)
1474 {
1475  RTMPContext *rt = s->priv_data;
1476  int t, ret;
1477 
1478  if (pkt->size < 2) {
1479  av_log(s, AV_LOG_ERROR, "Too short ping packet (%d)\n",
1480  pkt->size);
1481  return AVERROR_INVALIDDATA;
1482  }
1483 
1484  t = AV_RB16(pkt->data);
1485  if (t == 6) {
1486  if ((ret = gen_pong(s, rt, pkt)) < 0)
1487  return ret;
1488  } else if (t == 26) {
1489  if (rt->swfsize) {
1490  if ((ret = gen_swf_verification(s, rt)) < 0)
1491  return ret;
1492  } else {
1493  av_log(s, AV_LOG_WARNING, "Ignoring SWFVerification request.\n");
1494  }
1495  }
1496 
1497  return 0;
1498 }
1499 
1500  static int handle_client_bw(URLContext *s, RTMPPacket *pkt)
1501 {
1502  RTMPContext *rt = s->priv_data;
1503 
1504  if (pkt->size < 4) {
1505  av_log(s, AV_LOG_ERROR,
1506  "Client bandwidth report packet is less than 4 bytes long (%d)\n",
1507  pkt->size);
1508  return AVERROR_INVALIDDATA;
1509  }
1510 
1511  rt->client_report_size = AV_RB32(pkt->data);
1512  if (rt->client_report_size <= 0) {
1513  av_log(s, AV_LOG_ERROR, "Incorrect client bandwidth %d\n",
1514  rt->client_report_size);
1515  return AVERROR_INVALIDDATA;
1516 
1517  }
1518  av_log(s, AV_LOG_DEBUG, "Client bandwidth = %d\n", rt->client_report_size);
1519  rt->client_report_size >>= 1;
1520 
1521  return 0;
1522 }
1523 
1524  static int handle_server_bw(URLContext *s, RTMPPacket *pkt)
1525 {
1526  RTMPContext *rt = s->priv_data;
1527 
1528  if (pkt->size < 4) {
1529  av_log(s, AV_LOG_ERROR,
1530  "Too short server bandwidth report packet (%d)\n",
1531  pkt->size);
1532  return AVERROR_INVALIDDATA;
1533  }
1534 
1535  rt->server_bw = AV_RB32(pkt->data);
1536  if (rt->server_bw <= 0) {
1537  av_log(s, AV_LOG_ERROR, "Incorrect server bandwidth %d\n",
1538  rt->server_bw);
1539  return AVERROR_INVALIDDATA;
1540  }
1541  av_log(s, AV_LOG_DEBUG, "Server bandwidth = %d\n", rt->server_bw);
1542 
1543  return 0;
1544 }
1545 
1546  static int do_adobe_auth(RTMPContext *rt, const char *user, const char *salt,
1547  const char *opaque, const char *challenge)
1548 {
1549  uint8_t hash[16];
1550  char hashstr[AV_BASE64_SIZE(sizeof(hash))], challenge2[10];
1551  struct AVMD5 *md5 = av_md5_alloc();
1552  if (!md5)
1553  return AVERROR(ENOMEM);
1554 
1555  snprintf(challenge2, sizeof(challenge2), "%08x", av_get_random_seed());
1556 
1557  av_md5_init(md5);
1558  av_md5_update(md5, user, strlen(user));
1559  av_md5_update(md5, salt, strlen(salt));
1560  av_md5_update(md5, rt->password, strlen(rt->password));
1561  av_md5_final(md5, hash);
1562  av_base64_encode(hashstr, sizeof(hashstr), hash,
1563  sizeof(hash));
1564  av_md5_init(md5);
1565  av_md5_update(md5, hashstr, strlen(hashstr));
1566  if (opaque)
1567  av_md5_update(md5, opaque, strlen(opaque));
1568  else if (challenge)
1569  av_md5_update(md5, challenge, strlen(challenge));
1570  av_md5_update(md5, challenge2, strlen(challenge2));
1571  av_md5_final(md5, hash);
1572  av_base64_encode(hashstr, sizeof(hashstr), hash,
1573  sizeof(hash));
1574  snprintf(rt->auth_params, sizeof(rt->auth_params),
1575  "?authmod=%s&user=%s&challenge=%s&response=%s",
1576  "adobe", user, challenge2, hashstr);
1577  if (opaque)
1578  av_strlcatf(rt->auth_params, sizeof(rt->auth_params),
1579  "&opaque=%s", opaque);
1580 
1581  av_free(md5);
1582  return 0;
1583 }
1584 
1585  static int do_llnw_auth(RTMPContext *rt, const char *user, const char *nonce)
1586 {
1587  uint8_t hash[16];
1588  char hashstr1[33], hashstr2[33];
1589  const char *realm = "live";
1590  const char *method = "publish";
1591  const char *qop = "auth";
1592  const char *nc = "00000001";
1593  char cnonce[10];
1594  struct AVMD5 *md5 = av_md5_alloc();
1595  if (!md5)
1596  return AVERROR(ENOMEM);
1597 
1598  snprintf(cnonce, sizeof(cnonce), "%08x", av_get_random_seed());
1599 
1600  av_md5_init(md5);
1601  av_md5_update(md5, user, strlen(user));
1602  av_md5_update(md5, ":", 1);
1603  av_md5_update(md5, realm, strlen(realm));
1604  av_md5_update(md5, ":", 1);
1605  av_md5_update(md5, rt->password, strlen(rt->password));
1606  av_md5_final(md5, hash);
1607  ff_data_to_hex(hashstr1, hash, 16, 1);
1608  hashstr1[32] = '0円';
1609 
1610  av_md5_init(md5);
1611  av_md5_update(md5, method, strlen(method));
1612  av_md5_update(md5, ":/", 2);
1613  av_md5_update(md5, rt->app, strlen(rt->app));
1614  if (!strchr(rt->app, '/'))
1615  av_md5_update(md5, "/_definst_", strlen("/_definst_"));
1616  av_md5_final(md5, hash);
1617  ff_data_to_hex(hashstr2, hash, 16, 1);
1618  hashstr2[32] = '0円';
1619 
1620  av_md5_init(md5);
1621  av_md5_update(md5, hashstr1, strlen(hashstr1));
1622  av_md5_update(md5, ":", 1);
1623  if (nonce)
1624  av_md5_update(md5, nonce, strlen(nonce));
1625  av_md5_update(md5, ":", 1);
1626  av_md5_update(md5, nc, strlen(nc));
1627  av_md5_update(md5, ":", 1);
1628  av_md5_update(md5, cnonce, strlen(cnonce));
1629  av_md5_update(md5, ":", 1);
1630  av_md5_update(md5, qop, strlen(qop));
1631  av_md5_update(md5, ":", 1);
1632  av_md5_update(md5, hashstr2, strlen(hashstr2));
1633  av_md5_final(md5, hash);
1634  ff_data_to_hex(hashstr1, hash, 16, 1);
1635 
1636  snprintf(rt->auth_params, sizeof(rt->auth_params),
1637  "?authmod=%s&user=%s&nonce=%s&cnonce=%s&nc=%s&response=%s",
1638  "llnw", user, nonce, cnonce, nc, hashstr1);
1639 
1640  av_free(md5);
1641  return 0;
1642 }
1643 
1644  static int handle_connect_error(URLContext *s, const char *desc)
1645 {
1646  RTMPContext *rt = s->priv_data;
1647  char buf[300], *ptr, authmod[15];
1648  int i = 0, ret = 0;
1649  const char *user = "", *salt = "", *opaque = NULL,
1650  *challenge = NULL, *cptr = NULL, *nonce = NULL;
1651 
1652  if (!(cptr = strstr(desc, "authmod=adobe")) &&
1653  !(cptr = strstr(desc, "authmod=llnw"))) {
1654  av_log(s, AV_LOG_ERROR,
1655  "Unknown connect error (unsupported authentication method?)\n");
1656  return AVERROR_UNKNOWN;
1657  }
1658  cptr += strlen("authmod=");
1659  while (*cptr && *cptr != ' ' && i < sizeof(authmod) - 1)
1660  authmod[i++] = *cptr++;
1661  authmod[i] = '0円';
1662 
1663  if (!rt->username[0] || !rt->password[0]) {
1664  av_log(s, AV_LOG_ERROR, "No credentials set\n");
1665  return AVERROR_UNKNOWN;
1666  }
1667 
1668  if (strstr(desc, "?reason=authfailed")) {
1669  av_log(s, AV_LOG_ERROR, "Incorrect username/password\n");
1670  return AVERROR_UNKNOWN;
1671  } else if (strstr(desc, "?reason=nosuchuser")) {
1672  av_log(s, AV_LOG_ERROR, "Incorrect username\n");
1673  return AVERROR_UNKNOWN;
1674  }
1675 
1676  if (rt->auth_tried) {
1677  av_log(s, AV_LOG_ERROR, "Authentication failed\n");
1678  return AVERROR_UNKNOWN;
1679  }
1680 
1681  rt->auth_params[0] = '0円';
1682 
1683  if (strstr(desc, "code=403 need auth")) {
1684  snprintf(rt->auth_params, sizeof(rt->auth_params),
1685  "?authmod=%s&user=%s", authmod, rt->username);
1686  return 0;
1687  }
1688 
1689  if (!(cptr = strstr(desc, "?reason=needauth"))) {
1690  av_log(s, AV_LOG_ERROR, "No auth parameters found\n");
1691  return AVERROR_UNKNOWN;
1692  }
1693 
1694  av_strlcpy(buf, cptr + 1, sizeof(buf));
1695  ptr = buf;
1696 
1697  while (ptr) {
1698  char *next = strchr(ptr, '&');
1699  char *value = strchr(ptr, '=');
1700  if (next)
1701  *next++ = '0円';
1702  if (value)
1703  *value++ = '0円';
1704  if (!strcmp(ptr, "user")) {
1705  user = value;
1706  } else if (!strcmp(ptr, "salt")) {
1707  salt = value;
1708  } else if (!strcmp(ptr, "opaque")) {
1709  opaque = value;
1710  } else if (!strcmp(ptr, "challenge")) {
1711  challenge = value;
1712  } else if (!strcmp(ptr, "nonce")) {
1713  nonce = value;
1714  }
1715  ptr = next;
1716  }
1717 
1718  if (!strcmp(authmod, "adobe")) {
1719  if ((ret = do_adobe_auth(rt, user, salt, opaque, challenge)) < 0)
1720  return ret;
1721  } else {
1722  if ((ret = do_llnw_auth(rt, user, nonce)) < 0)
1723  return ret;
1724  }
1725 
1726  rt->auth_tried = 1;
1727  return 0;
1728 }
1729 
1730  static int handle_invoke_error(URLContext *s, RTMPPacket *pkt)
1731 {
1732  RTMPContext *rt = s->priv_data;
1733  const uint8_t *data_end = pkt->data + pkt->size;
1734  char *tracked_method = NULL;
1735  int level = AV_LOG_ERROR;
1736  uint8_t tmpstr[256];
1737  int ret;
1738 
1739  if ((ret = find_tracked_method(s, pkt, 9, &tracked_method)) < 0)
1740  return ret;
1741 
1742  if (!ff_amf_get_field_value(pkt->data + 9, data_end,
1743  "description", tmpstr, sizeof(tmpstr))) {
1744  if (tracked_method && (!strcmp(tracked_method, "_checkbw") ||
1745  !strcmp(tracked_method, "releaseStream") ||
1746  !strcmp(tracked_method, "FCSubscribe") ||
1747  !strcmp(tracked_method, "FCPublish"))) {
1748  /* Gracefully ignore Adobe-specific historical artifact errors. */
1749  level = AV_LOG_WARNING;
1750  ret = 0;
1751  } else if (tracked_method && !strcmp(tracked_method, "connect")) {
1752  ret = handle_connect_error(s, tmpstr);
1753  if (!ret) {
1754  rt->do_reconnect = 1;
1755  level = AV_LOG_VERBOSE;
1756  }
1757  } else
1758  ret = AVERROR_UNKNOWN;
1759  av_log(s, level, "Server error: %s\n", tmpstr);
1760  }
1761 
1762  av_free(tracked_method);
1763  return ret;
1764 }
1765 
1766  static int write_begin(URLContext *s)
1767 {
1768  RTMPContext *rt = s->priv_data;
1769  PutByteContext pbc;
1770  RTMPPacket spkt = { 0 };
1771  int ret;
1772 
1773  // Send Stream Begin 1
1774  if ((ret = ff_rtmp_packet_create(&spkt, RTMP_NETWORK_CHANNEL,
1775  RTMP_PT_PING, 0, 6)) < 0) {
1776  av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1777  return ret;
1778  }
1779 
1780  bytestream2_init_writer(&pbc, spkt.data, spkt.size);
1781  bytestream2_put_be16(&pbc, 0); // 0 -> Stream Begin
1782  bytestream2_put_be32(&pbc, rt->nb_streamid);
1783 
1784  ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
1785  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
1786 
1787  ff_rtmp_packet_destroy(&spkt);
1788 
1789  return ret;
1790 }
1791 
1792  static int write_status(URLContext *s, RTMPPacket *pkt,
1793  const char *status, const char *filename)
1794 {
1795  RTMPContext *rt = s->priv_data;
1796  RTMPPacket spkt = { 0 };
1797  char statusmsg[128];
1798  uint8_t *pp;
1799  int ret;
1800 
1801  if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1802  RTMP_PT_INVOKE, 0,
1803  RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1804  av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1805  return ret;
1806  }
1807 
1808  pp = spkt.data;
1809  spkt.extra = pkt->extra;
1810  ff_amf_write_string(&pp, "onStatus");
1811  ff_amf_write_number(&pp, 0);
1812  ff_amf_write_null(&pp);
1813 
1814  ff_amf_write_object_start(&pp);
1815  ff_amf_write_field_name(&pp, "level");
1816  ff_amf_write_string(&pp, "status");
1817  ff_amf_write_field_name(&pp, "code");
1818  ff_amf_write_string(&pp, status);
1819  ff_amf_write_field_name(&pp, "description");
1820  snprintf(statusmsg, sizeof(statusmsg),
1821  "%s is now published", filename);
1822  ff_amf_write_string(&pp, statusmsg);
1823  ff_amf_write_field_name(&pp, "details");
1824  ff_amf_write_string(&pp, filename);
1825  ff_amf_write_field_name(&pp, "clientid");
1826  snprintf(statusmsg, sizeof(statusmsg), "%s", LIBAVFORMAT_IDENT);
1827  ff_amf_write_string(&pp, statusmsg);
1828  ff_amf_write_object_end(&pp);
1829 
1830  spkt.size = pp - spkt.data;
1831  ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
1832  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
1833  ff_rtmp_packet_destroy(&spkt);
1834 
1835  return ret;
1836 }
1837 
1838  static int send_invoke_response(URLContext *s, RTMPPacket *pkt)
1839 {
1840  RTMPContext *rt = s->priv_data;
1841  double seqnum;
1842  char filename[64];
1843  char command[64];
1844  int stringlen;
1845  char *pchar;
1846  const uint8_t *p = pkt->data;
1847  uint8_t *pp = NULL;
1848  RTMPPacket spkt = { 0 };
1849  GetByteContext gbc;
1850  int ret;
1851 
1852  bytestream2_init(&gbc, p, pkt->size);
1853  if (ff_amf_read_string(&gbc, command, sizeof(command),
1854  &stringlen)) {
1855  av_log(s, AV_LOG_ERROR, "Error in PT_INVOKE\n");
1856  return AVERROR_INVALIDDATA;
1857  }
1858 
1859  ret = ff_amf_read_number(&gbc, &seqnum);
1860  if (ret)
1861  return ret;
1862  ret = ff_amf_read_null(&gbc);
1863  if (ret)
1864  return ret;
1865  if (!strcmp(command, "FCPublish") ||
1866  !strcmp(command, "publish")) {
1867  ret = ff_amf_read_string(&gbc, filename,
1868  sizeof(filename), &stringlen);
1869  // check with url
1870  if (s->filename) {
1871  pchar = strrchr(s->filename, '/');
1872  if (!pchar) {
1873  av_log(s, AV_LOG_WARNING,
1874  "Unable to find / in url %s, bad format\n",
1875  s->filename);
1876  pchar = s->filename;
1877  }
1878  pchar++;
1879  if (strcmp(pchar, filename))
1880  av_log(s, AV_LOG_WARNING, "Unexpected stream %s, expecting"
1881  " %s\n", filename, pchar);
1882  }
1883  rt->state = STATE_RECEIVING;
1884  }
1885 
1886  if (!strcmp(command, "FCPublish")) {
1887  if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1888  RTMP_PT_INVOKE, 0,
1889  RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1890  av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1891  return ret;
1892  }
1893  pp = spkt.data;
1894  ff_amf_write_string(&pp, "onFCPublish");
1895  } else if (!strcmp(command, "publish")) {
1896  ret = write_begin(s);
1897  if (ret < 0)
1898  return ret;
1899 
1900  // Send onStatus(NetStream.Publish.Start)
1901  return write_status(s, pkt, "NetStream.Publish.Start",
1902  filename);
1903  } else if (!strcmp(command, "play")) {
1904  ret = write_begin(s);
1905  if (ret < 0)
1906  return ret;
1907  rt->state = STATE_SENDING;
1908  return write_status(s, pkt, "NetStream.Play.Start",
1909  filename);
1910  } else {
1911  if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1912  RTMP_PT_INVOKE, 0,
1913  RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1914  av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1915  return ret;
1916  }
1917  pp = spkt.data;
1918  ff_amf_write_string(&pp, "_result");
1919  ff_amf_write_number(&pp, seqnum);
1920  ff_amf_write_null(&pp);
1921  if (!strcmp(command, "createStream")) {
1922  rt->nb_streamid++;
1923  if (rt->nb_streamid == 0 || rt->nb_streamid == 2)
1924  rt->nb_streamid++; /* Values 0 and 2 are reserved */
1925  ff_amf_write_number(&pp, rt->nb_streamid);
1926  /* By now we don't control which streams are removed in
1927  * deleteStream. There is no stream creation control
1928  * if a client creates more than 2^32 - 2 streams. */
1929  }
1930  }
1931  spkt.size = pp - spkt.data;
1932  ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
1933  &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
1934  ff_rtmp_packet_destroy(&spkt);
1935  return ret;
1936 }
1937 
1938  static int handle_invoke_result(URLContext *s, RTMPPacket *pkt)
1939 {
1940  RTMPContext *rt = s->priv_data;
1941  char *tracked_method = NULL;
1942  int ret = 0;
1943 
1944  if ((ret = find_tracked_method(s, pkt, 10, &tracked_method)) < 0)
1945  return ret;
1946 
1947  if (!tracked_method) {
1948  /* Ignore this reply when the current method is not tracked. */
1949  return ret;
1950  }
1951 
1952  if (!strcmp(tracked_method, "connect")) {
1953  if (!rt->is_input) {
1954  if ((ret = gen_release_stream(s, rt)) < 0)
1955  goto fail;
1956 
1957  if ((ret = gen_fcpublish_stream(s, rt)) < 0)
1958  goto fail;
1959  } else {
1960  if ((ret = gen_server_bw(s, rt)) < 0)
1961  goto fail;
1962  }
1963 
1964  if ((ret = gen_create_stream(s, rt)) < 0)
1965  goto fail;
1966 
1967  if (rt->is_input) {
1968  /* Send the FCSubscribe command when the name of live
1969  * stream is defined by the user or if it's a live stream. */
1970  if (rt->subscribe) {
1971  if ((ret = gen_fcsubscribe_stream(s, rt, rt->subscribe)) < 0)
1972  goto fail;
1973  } else if (rt->live == -1) {
1974  if ((ret = gen_fcsubscribe_stream(s, rt, rt->playpath)) < 0)
1975  goto fail;
1976  }
1977  }
1978  } else if (!strcmp(tracked_method, "createStream")) {
1979  //extract a number from the result
1980  if (pkt->data[10] || pkt->data[19] != 5 || pkt->data[20]) {
1981  av_log(s, AV_LOG_WARNING, "Unexpected reply on connect()\n");
1982  } else {
1983  rt->stream_id = av_int2double(AV_RB64(pkt->data + 21));
1984  }
1985 
1986  if (!rt->is_input) {
1987  if ((ret = gen_publish(s, rt)) < 0)
1988  goto fail;
1989  } else {
1990  if ((ret = gen_play(s, rt)) < 0)
1991  goto fail;
1992  if ((ret = gen_buffer_time(s, rt)) < 0)
1993  goto fail;
1994  }
1995  }
1996 
1997 fail:
1998  av_free(tracked_method);
1999  return ret;
2000 }
2001 
2002  static int handle_invoke_status(URLContext *s, RTMPPacket *pkt)
2003 {
2004  RTMPContext *rt = s->priv_data;
2005  const uint8_t *data_end = pkt->data + pkt->size;
2006  const uint8_t *ptr = pkt->data + RTMP_HEADER;
2007  uint8_t tmpstr[256];
2008  int i, t;
2009 
2010  for (i = 0; i < 2; i++) {
2011  t = ff_amf_tag_size(ptr, data_end);
2012  if (t < 0)
2013  return 1;
2014  ptr += t;
2015  }
2016 
2017  t = ff_amf_get_field_value(ptr, data_end, "level", tmpstr, sizeof(tmpstr));
2018  if (!t && !strcmp(tmpstr, "error")) {
2019  t = ff_amf_get_field_value(ptr, data_end,
2020  "description", tmpstr, sizeof(tmpstr));
2021  if (t || !tmpstr[0])
2022  t = ff_amf_get_field_value(ptr, data_end, "code",
2023  tmpstr, sizeof(tmpstr));
2024  if (!t)
2025  av_log(s, AV_LOG_ERROR, "Server error: %s\n", tmpstr);
2026  return -1;
2027  }
2028 
2029  t = ff_amf_get_field_value(ptr, data_end, "code", tmpstr, sizeof(tmpstr));
2030  if (!t && !strcmp(tmpstr, "NetStream.Play.Start")) rt->state = STATE_PLAYING;
2031  if (!t && !strcmp(tmpstr, "NetStream.Play.Stop")) rt->state = STATE_STOPPED;
2032  if (!t && !strcmp(tmpstr, "NetStream.Play.UnpublishNotify")) rt->state = STATE_STOPPED;
2033  if (!t && !strcmp(tmpstr, "NetStream.Publish.Start")) rt->state = STATE_PUBLISHING;
2034  if (!t && !strcmp(tmpstr, "NetStream.Seek.Notify")) rt->state = STATE_PLAYING;
2035 
2036  return 0;
2037 }
2038 
2039  static int handle_invoke(URLContext *s, RTMPPacket *pkt)
2040 {
2041  RTMPContext *rt = s->priv_data;
2042  int ret = 0;
2043 
2044  //TODO: check for the messages sent for wrong state?
2045  if (ff_amf_match_string(pkt->data, pkt->size, "_error")) {
2046  if ((ret = handle_invoke_error(s, pkt)) < 0)
2047  return ret;
2048  } else if (ff_amf_match_string(pkt->data, pkt->size, "_result")) {
2049  if ((ret = handle_invoke_result(s, pkt)) < 0)
2050  return ret;
2051  } else if (ff_amf_match_string(pkt->data, pkt->size, "onStatus")) {
2052  if ((ret = handle_invoke_status(s, pkt)) < 0)
2053  return ret;
2054  } else if (ff_amf_match_string(pkt->data, pkt->size, "onBWDone")) {
2055  if ((ret = gen_check_bw(s, rt)) < 0)
2056  return ret;
2057  } else if (ff_amf_match_string(pkt->data, pkt->size, "releaseStream") ||
2058  ff_amf_match_string(pkt->data, pkt->size, "FCPublish") ||
2059  ff_amf_match_string(pkt->data, pkt->size, "publish") ||
2060  ff_amf_match_string(pkt->data, pkt->size, "play") ||
2061  ff_amf_match_string(pkt->data, pkt->size, "_checkbw") ||
2062  ff_amf_match_string(pkt->data, pkt->size, "createStream")) {
2063  if ((ret = send_invoke_response(s, pkt)) < 0)
2064  return ret;
2065  }
2066 
2067  return ret;
2068 }
2069 
2070  static int update_offset(RTMPContext *rt, int size)
2071 {
2072  int old_flv_size;
2073 
2074  // generate packet header and put data into buffer for FLV demuxer
2075  if (rt->flv_off < rt->flv_size) {
2076  // There is old unread data in the buffer, thus append at the end
2077  old_flv_size = rt->flv_size;
2078  rt->flv_size += size;
2079  } else {
2080  // All data has been read, write the new data at the start of the buffer
2081  old_flv_size = 0;
2082  rt->flv_size = size;
2083  rt->flv_off = 0;
2084  }
2085 
2086  return old_flv_size;
2087 }
2088 
2089  static int append_flv_data(RTMPContext *rt, RTMPPacket *pkt, int skip)
2090 {
2091  int old_flv_size, ret;
2092  PutByteContext pbc;
2093  const uint8_t *data = pkt->data + skip;
2094  const int size = pkt->size - skip;
2095  uint32_t ts = pkt->timestamp;
2096 
2097  old_flv_size = update_offset(rt, size + 15);
2098 
2099  if ((ret = av_reallocp(&rt->flv_data, rt->flv_size)) < 0) {
2100  rt->flv_size = rt->flv_off = 0;
2101  return ret;
2102  }
2103  bytestream2_init_writer(&pbc, rt->flv_data, rt->flv_size);
2104  bytestream2_skip_p(&pbc, old_flv_size);
2105  bytestream2_put_byte(&pbc, pkt->type);
2106  bytestream2_put_be24(&pbc, size);
2107  bytestream2_put_be24(&pbc, ts);
2108  bytestream2_put_byte(&pbc, ts >> 24);
2109  bytestream2_put_be24(&pbc, 0);
2110  bytestream2_put_buffer(&pbc, data, size);
2111  bytestream2_put_be32(&pbc, 0);
2112 
2113  return 0;
2114 }
2115 
2116  static int handle_notify(URLContext *s, RTMPPacket *pkt)
2117 {
2118  RTMPContext *rt = s->priv_data;
2119  uint8_t commandbuffer[64];
2120  char statusmsg[128];
2121  int stringlen, ret, skip = 0;
2122  GetByteContext gbc;
2123 
2124  bytestream2_init(&gbc, pkt->data, pkt->size);
2125  if (ff_amf_read_string(&gbc, commandbuffer, sizeof(commandbuffer),
2126  &stringlen))
2127  return AVERROR_INVALIDDATA;
2128 
2129  // Skip the @setDataFrame string and validate it is a notification
2130  if (!strcmp(commandbuffer, "@setDataFrame")) {
2131  skip = gbc.buffer - pkt->data;
2132  ret = ff_amf_read_string(&gbc, statusmsg,
2133  sizeof(statusmsg), &stringlen);
2134  if (ret < 0)
2135  return AVERROR_INVALIDDATA;
2136  }
2137 
2138  return append_flv_data(rt, pkt, skip);
2139 }
2140 
2141 /**
2142  * Parse received packet and possibly perform some action depending on
2143  * the packet contents.
2144  * @return 0 for no errors, negative values for serious errors which prevent
2145  * further communications, positive values for uncritical errors
2146  */
2147  static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
2148 {
2149  int ret;
2150 
2151 #ifdef DEBUG
2152  ff_rtmp_packet_dump(s, pkt);
2153 #endif
2154 
2155  switch (pkt->type) {
2156  case RTMP_PT_BYTES_READ:
2157  av_dlog(s, "received bytes read report\n");
2158  break;
2159  case RTMP_PT_CHUNK_SIZE:
2160  if ((ret = handle_chunk_size(s, pkt)) < 0)
2161  return ret;
2162  break;
2163  case RTMP_PT_PING:
2164  if ((ret = handle_ping(s, pkt)) < 0)
2165  return ret;
2166  break;
2167  case RTMP_PT_CLIENT_BW:
2168  if ((ret = handle_client_bw(s, pkt)) < 0)
2169  return ret;
2170  break;
2171  case RTMP_PT_SERVER_BW:
2172  if ((ret = handle_server_bw(s, pkt)) < 0)
2173  return ret;
2174  break;
2175  case RTMP_PT_INVOKE:
2176  if ((ret = handle_invoke(s, pkt)) < 0)
2177  return ret;
2178  break;
2179  case RTMP_PT_VIDEO:
2180  case RTMP_PT_AUDIO:
2181  case RTMP_PT_METADATA:
2182  case RTMP_PT_NOTIFY:
2183  /* Audio, Video and Metadata packets are parsed in get_packet() */
2184  break;
2185  default:
2186  av_log(s, AV_LOG_VERBOSE, "Unknown packet type received 0x%02X\n", pkt->type);
2187  break;
2188  }
2189  return 0;
2190 }
2191 
2192  static int handle_metadata(RTMPContext *rt, RTMPPacket *pkt)
2193 {
2194  int ret, old_flv_size, type;
2195  const uint8_t *next;
2196  uint8_t *p;
2197  uint32_t size;
2198  uint32_t ts, cts, pts = 0;
2199 
2200  old_flv_size = update_offset(rt, pkt->size);
2201 
2202  if ((ret = av_reallocp(&rt->flv_data, rt->flv_size)) < 0) {
2203  rt->flv_size = rt->flv_off = 0;
2204  return ret;
2205  }
2206 
2207  next = pkt->data;
2208  p = rt->flv_data + old_flv_size;
2209 
2210  /* copy data while rewriting timestamps */
2211  ts = pkt->timestamp;
2212 
2213  while (next - pkt->data < pkt->size - RTMP_HEADER) {
2214  type = bytestream_get_byte(&next);
2215  size = bytestream_get_be24(&next);
2216  cts = bytestream_get_be24(&next);
2217  cts |= bytestream_get_byte(&next) << 24;
2218  if (!pts)
2219  pts = cts;
2220  ts += cts - pts;
2221  pts = cts;
2222  if (size + 3 + 4 > pkt->data + pkt->size - next)
2223  break;
2224  bytestream_put_byte(&p, type);
2225  bytestream_put_be24(&p, size);
2226  bytestream_put_be24(&p, ts);
2227  bytestream_put_byte(&p, ts >> 24);
2228  memcpy(p, next, size + 3 + 4);
2229  next += size + 3 + 4;
2230  p += size + 3 + 4;
2231  }
2232  if (p != rt->flv_data + rt->flv_size) {
2233  av_log(NULL, AV_LOG_WARNING, "Incomplete flv packets in "
2234  "RTMP_PT_METADATA packet\n");
2235  rt->flv_size = p - rt->flv_data;
2236  }
2237 
2238  return 0;
2239 }
2240 
2241 /**
2242  * Interact with the server by receiving and sending RTMP packets until
2243  * there is some significant data (media data or expected status notification).
2244  *
2245  * @param s reading context
2246  * @param for_header non-zero value tells function to work until it
2247  * gets notification from the server that playing has been started,
2248  * otherwise function will work until some media data is received (or
2249  * an error happens)
2250  * @return 0 for successful operation, negative value in case of error
2251  */
2252  static int get_packet(URLContext *s, int for_header)
2253 {
2254  RTMPContext *rt = s->priv_data;
2255  int ret;
2256 
2257  if (rt->state == STATE_STOPPED)
2258  return AVERROR_EOF;
2259 
2260  for (;;) {
2261  RTMPPacket rpkt = { 0 };
2262  if ((ret = ff_rtmp_packet_read(rt->stream, &rpkt,
2263  rt->in_chunk_size, &rt->prev_pkt[0],
2264  &rt->nb_prev_pkt[0])) <= 0) {
2265  if (ret == 0) {
2266  return AVERROR(EAGAIN);
2267  } else {
2268  return AVERROR(EIO);
2269  }
2270  }
2271  rt->bytes_read += ret;
2272  if (rt->bytes_read - rt->last_bytes_read > rt->client_report_size) {
2273  av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
2274  if ((ret = gen_bytes_read(s, rt, rpkt.timestamp + 1)) < 0)
2275  return ret;
2276  rt->last_bytes_read = rt->bytes_read;
2277  }
2278 
2279  ret = rtmp_parse_result(s, rt, &rpkt);
2280 
2281  // At this point we must check if we are in the seek state and continue
2282  // with the next packet. handle_invoke will get us out of this state
2283  // when the right message is encountered
2284  if (rt->state == STATE_SEEKING) {
2285  ff_rtmp_packet_destroy(&rpkt);
2286  // We continue, let the natural flow of things happen:
2287  // AVERROR(EAGAIN) or handle_invoke gets us out of here
2288  continue;
2289  }
2290 
2291  if (ret < 0) {//serious error in current packet
2292  ff_rtmp_packet_destroy(&rpkt);
2293  return ret;
2294  }
2295  if (rt->do_reconnect && for_header) {
2296  ff_rtmp_packet_destroy(&rpkt);
2297  return 0;
2298  }
2299  if (rt->state == STATE_STOPPED) {
2300  ff_rtmp_packet_destroy(&rpkt);
2301  return AVERROR_EOF;
2302  }
2303  if (for_header && (rt->state == STATE_PLAYING ||
2304  rt->state == STATE_PUBLISHING ||
2305  rt->state == STATE_SENDING ||
2306  rt->state == STATE_RECEIVING)) {
2307  ff_rtmp_packet_destroy(&rpkt);
2308  return 0;
2309  }
2310  if (!rpkt.size || !rt->is_input) {
2311  ff_rtmp_packet_destroy(&rpkt);
2312  continue;
2313  }
2314  if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO) {
2315  ret = append_flv_data(rt, &rpkt, 0);
2316  ff_rtmp_packet_destroy(&rpkt);
2317  return ret;
2318  } else if (rpkt.type == RTMP_PT_NOTIFY) {
2319  ret = handle_notify(s, &rpkt);
2320  ff_rtmp_packet_destroy(&rpkt);
2321  return ret;
2322  } else if (rpkt.type == RTMP_PT_METADATA) {
2323  ret = handle_metadata(rt, &rpkt);
2324  ff_rtmp_packet_destroy(&rpkt);
2325  return 0;
2326  }
2327  ff_rtmp_packet_destroy(&rpkt);
2328  }
2329 }
2330 
2331  static int rtmp_close(URLContext *h)
2332 {
2333  RTMPContext *rt = h->priv_data;
2334  int ret = 0, i, j;
2335 
2336  if (!rt->is_input) {
2337  rt->flv_data = NULL;
2338  if (rt->out_pkt.size)
2339  ff_rtmp_packet_destroy(&rt->out_pkt);
2340  if (rt->state > STATE_FCPUBLISH)
2341  ret = gen_fcunpublish_stream(h, rt);
2342  }
2343  if (rt->state > STATE_HANDSHAKED)
2344  ret = gen_delete_stream(h, rt);
2345  for (i = 0; i < 2; i++) {
2346  for (j = 0; j < rt->nb_prev_pkt[i]; j++)
2347  ff_rtmp_packet_destroy(&rt->prev_pkt[i][j]);
2348  av_freep(&rt->prev_pkt[i]);
2349  }
2350 
2351  free_tracked_methods(rt);
2352  av_freep(&rt->flv_data);
2353  ffurl_close(rt->stream);
2354  return ret;
2355 }
2356 
2357 /**
2358  * Open RTMP connection and verify that the stream can be played.
2359  *
2360  * URL syntax: rtmp://server[:port][/app][/playpath]
2361  * where 'app' is first one or two directories in the path
2362  * (e.g. /ondemand/, /flash/live/, etc.)
2363  * and 'playpath' is a file name (the rest of the path,
2364  * may be prefixed with "mp4:")
2365  */
2366  static int rtmp_open(URLContext *s, const char *uri, int flags)
2367 {
2368  RTMPContext *rt = s->priv_data;
2369  char proto[8], hostname[256], path[1024], auth[100], *fname;
2370  char *old_app;
2371  uint8_t buf[2048];
2372  int port;
2373  AVDictionary *opts = NULL;
2374  int ret;
2375 
2376  if (rt->listen_timeout > 0)
2377  rt->listen = 1;
2378 
2379  rt->is_input = !(flags & AVIO_FLAG_WRITE);
2380 
2381  av_url_split(proto, sizeof(proto), auth, sizeof(auth),
2382  hostname, sizeof(hostname), &port,
2383  path, sizeof(path), s->filename);
2384 
2385  if (strchr(path, ' ')) {
2386  av_log(s, AV_LOG_WARNING,
2387  "Detected librtmp style URL parameters, these aren't supported "
2388  "by the libavformat internal RTMP handler currently enabled. "
2389  "See the documentation for the correct way to pass parameters.\n");
2390  }
2391 
2392  if (auth[0]) {
2393  char *ptr = strchr(auth, ':');
2394  if (ptr) {
2395  *ptr = '0円';
2396  av_strlcpy(rt->username, auth, sizeof(rt->username));
2397  av_strlcpy(rt->password, ptr + 1, sizeof(rt->password));
2398  }
2399  }
2400 
2401  if (rt->listen && strcmp(proto, "rtmp")) {
2402  av_log(s, AV_LOG_ERROR, "rtmp_listen not available for %s\n",
2403  proto);
2404  return AVERROR(EINVAL);
2405  }
2406  if (!strcmp(proto, "rtmpt") || !strcmp(proto, "rtmpts")) {
2407  if (!strcmp(proto, "rtmpts"))
2408  av_dict_set(&opts, "ffrtmphttp_tls", "1", 1);
2409 
2410  /* open the http tunneling connection */
2411  ff_url_join(buf, sizeof(buf), "ffrtmphttp", NULL, hostname, port, NULL);
2412  } else if (!strcmp(proto, "rtmps")) {
2413  /* open the tls connection */
2414  if (port < 0)
2415  port = RTMPS_DEFAULT_PORT;
2416  ff_url_join(buf, sizeof(buf), "tls", NULL, hostname, port, NULL);
2417  } else if (!strcmp(proto, "rtmpe") || (!strcmp(proto, "rtmpte"))) {
2418  if (!strcmp(proto, "rtmpte"))
2419  av_dict_set(&opts, "ffrtmpcrypt_tunneling", "1", 1);
2420 
2421  /* open the encrypted connection */
2422  ff_url_join(buf, sizeof(buf), "ffrtmpcrypt", NULL, hostname, port, NULL);
2423  rt->encrypted = 1;
2424  } else {
2425  /* open the tcp connection */
2426  if (port < 0)
2427  port = RTMP_DEFAULT_PORT;
2428  if (rt->listen)
2429  ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port,
2430  "?listen&listen_timeout=%d",
2431  rt->listen_timeout * 1000);
2432  else
2433  ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port, NULL);
2434  }
2435 
2436 reconnect:
2437  if ((ret = ffurl_open(&rt->stream, buf, AVIO_FLAG_READ_WRITE,
2438  &s->interrupt_callback, &opts)) < 0) {
2439  av_log(s , AV_LOG_ERROR, "Cannot open connection %s\n", buf);
2440  goto fail;
2441  }
2442 
2443  if (rt->swfverify) {
2444  if ((ret = rtmp_calc_swfhash(s)) < 0)
2445  goto fail;
2446  }
2447 
2448  rt->state = STATE_START;
2449  if (!rt->listen && (ret = rtmp_handshake(s, rt)) < 0)
2450  goto fail;
2451  if (rt->listen && (ret = rtmp_server_handshake(s, rt)) < 0)
2452  goto fail;
2453 
2454  rt->out_chunk_size = 128;
2455  rt->in_chunk_size = 128; // Probably overwritten later
2456  rt->state = STATE_HANDSHAKED;
2457 
2458  // Keep the application name when it has been defined by the user.
2459  old_app = rt->app;
2460 
2461  rt->app = av_malloc(APP_MAX_LENGTH);
2462  if (!rt->app) {
2463  ret = AVERROR(ENOMEM);
2464  goto fail;
2465  }
2466 
2467  //extract "app" part from path
2468  if (!strncmp(path, "/ondemand/", 10)) {
2469  fname = path + 10;
2470  memcpy(rt->app, "ondemand", 9);
2471  } else {
2472  char *next = *path ? path + 1 : path;
2473  char *p = strchr(next, '/');
2474  if (!p) {
2475  fname = next;
2476  rt->app[0] = '0円';
2477  } else {
2478  // make sure we do not mismatch a playpath for an application instance
2479  char *c = strchr(p + 1, ':');
2480  fname = strchr(p + 1, '/');
2481  if (!fname || (c && c < fname)) {
2482  fname = p + 1;
2483  av_strlcpy(rt->app, path + 1, FFMIN(p - path, APP_MAX_LENGTH));
2484  } else {
2485  fname++;
2486  av_strlcpy(rt->app, path + 1, FFMIN(fname - path - 1, APP_MAX_LENGTH));
2487  }
2488  }
2489  }
2490 
2491  if (old_app) {
2492  // The name of application has been defined by the user, override it.
2493  if (strlen(old_app) >= APP_MAX_LENGTH) {
2494  ret = AVERROR(EINVAL);
2495  goto fail;
2496  }
2497  av_free(rt->app);
2498  rt->app = old_app;
2499  }
2500 
2501  if (!rt->playpath) {
2502  int len = strlen(fname);
2503 
2504  rt->playpath = av_malloc(PLAYPATH_MAX_LENGTH);
2505  if (!rt->playpath) {
2506  ret = AVERROR(ENOMEM);
2507  goto fail;
2508  }
2509 
2510  if (!strchr(fname, ':') && len >= 4 &&
2511  (!strcmp(fname + len - 4, ".f4v") ||
2512  !strcmp(fname + len - 4, ".mp4"))) {
2513  memcpy(rt->playpath, "mp4:", 5);
2514  } else if (len >= 4 && !strcmp(fname + len - 4, ".flv")) {
2515  fname[len - 4] = '0円';
2516  } else {
2517  rt->playpath[0] = 0;
2518  }
2519  av_strlcat(rt->playpath, fname, PLAYPATH_MAX_LENGTH);
2520  }
2521 
2522  if (!rt->tcurl) {
2523  rt->tcurl = av_malloc(TCURL_MAX_LENGTH);
2524  if (!rt->tcurl) {
2525  ret = AVERROR(ENOMEM);
2526  goto fail;
2527  }
2528  ff_url_join(rt->tcurl, TCURL_MAX_LENGTH, proto, NULL, hostname,
2529  port, "/%s", rt->app);
2530  }
2531 
2532  if (!rt->flashver) {
2533  rt->flashver = av_malloc(FLASHVER_MAX_LENGTH);
2534  if (!rt->flashver) {
2535  ret = AVERROR(ENOMEM);
2536  goto fail;
2537  }
2538  if (rt->is_input) {
2539  snprintf(rt->flashver, FLASHVER_MAX_LENGTH, "%s %d,%d,%d,%d",
2540  RTMP_CLIENT_PLATFORM, RTMP_CLIENT_VER1, RTMP_CLIENT_VER2,
2541  RTMP_CLIENT_VER3, RTMP_CLIENT_VER4);
2542  } else {
2543  snprintf(rt->flashver, FLASHVER_MAX_LENGTH,
2544  "FMLE/3.0 (compatible; %s)", LIBAVFORMAT_IDENT);
2545  }
2546  }
2547 
2548  rt->client_report_size = 1048576;
2549  rt->bytes_read = 0;
2550  rt->last_bytes_read = 0;
2551  rt->server_bw = 2500000;
2552 
2553  av_log(s, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
2554  proto, path, rt->app, rt->playpath);
2555  if (!rt->listen) {
2556  if ((ret = gen_connect(s, rt)) < 0)
2557  goto fail;
2558  } else {
2559  if (read_connect(s, s->priv_data) < 0)
2560  goto fail;
2561  }
2562 
2563  do {
2564  ret = get_packet(s, 1);
2565  } while (ret == AVERROR(EAGAIN));
2566  if (ret < 0)
2567  goto fail;
2568 
2569  if (rt->do_reconnect) {
2570  int i;
2571  ffurl_close(rt->stream);
2572  rt->stream = NULL;
2573  rt->do_reconnect = 0;
2574  rt->nb_invokes = 0;
2575  for (i = 0; i < 2; i++)
2576  memset(rt->prev_pkt[i], 0,
2577  sizeof(**rt->prev_pkt) * rt->nb_prev_pkt[i]);
2578  free_tracked_methods(rt);
2579  goto reconnect;
2580  }
2581 
2582  if (rt->is_input) {
2583  int err;
2584  // generate FLV header for demuxer
2585  rt->flv_size = 13;
2586  if ((err = av_reallocp(&rt->flv_data, rt->flv_size)) < 0)
2587  return err;
2588  rt->flv_off = 0;
2589  memcpy(rt->flv_data, "FLV1円5円0円0円0円011円0円0円0円0円", rt->flv_size);
2590  } else {
2591  rt->flv_size = 0;
2592  rt->flv_data = NULL;
2593  rt->flv_off = 0;
2594  rt->skip_bytes = 13;
2595  }
2596 
2597  s->max_packet_size = rt->stream->max_packet_size;
2598  s->is_streamed = 1;
2599  return 0;
2600 
2601 fail:
2602  av_dict_free(&opts);
2603  rtmp_close(s);
2604  return ret;
2605 }
2606 
2607  static int rtmp_read(URLContext *s, uint8_t *buf, int size)
2608 {
2609  RTMPContext *rt = s->priv_data;
2610  int orig_size = size;
2611  int ret;
2612 
2613  while (size > 0) {
2614  int data_left = rt->flv_size - rt->flv_off;
2615 
2616  if (data_left >= size) {
2617  memcpy(buf, rt->flv_data + rt->flv_off, size);
2618  rt->flv_off += size;
2619  return orig_size;
2620  }
2621  if (data_left > 0) {
2622  memcpy(buf, rt->flv_data + rt->flv_off, data_left);
2623  buf += data_left;
2624  size -= data_left;
2625  rt->flv_off = rt->flv_size;
2626  return data_left;
2627  }
2628  if ((ret = get_packet(s, 0)) < 0)
2629  return ret;
2630  }
2631  return orig_size;
2632 }
2633 
2634  static int64_t rtmp_seek(URLContext *s, int stream_index, int64_t timestamp,
2635  int flags)
2636 {
2637  RTMPContext *rt = s->priv_data;
2638  int ret;
2639  av_log(s, AV_LOG_DEBUG,
2640  "Seek on stream index %d at timestamp %"PRId64" with flags %08x\n",
2641  stream_index, timestamp, flags);
2642  if ((ret = gen_seek(s, rt, timestamp)) < 0) {
2643  av_log(s, AV_LOG_ERROR,
2644  "Unable to send seek command on stream index %d at timestamp "
2645  "%"PRId64" with flags %08x\n",
2646  stream_index, timestamp, flags);
2647  return ret;
2648  }
2649  rt->flv_off = rt->flv_size;
2650  rt->state = STATE_SEEKING;
2651  return timestamp;
2652 }
2653 
2654  static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
2655 {
2656  RTMPContext *rt = s->priv_data;
2657  int size_temp = size;
2658  int pktsize, pkttype;
2659  uint32_t ts;
2660  const uint8_t *buf_temp = buf;
2661  uint8_t c;
2662  int ret;
2663 
2664  do {
2665  if (rt->skip_bytes) {
2666  int skip = FFMIN(rt->skip_bytes, size_temp);
2667  buf_temp += skip;
2668  size_temp -= skip;
2669  rt->skip_bytes -= skip;
2670  continue;
2671  }
2672 
2673  if (rt->flv_header_bytes < RTMP_HEADER) {
2674  const uint8_t *header = rt->flv_header;
2675  int copy = FFMIN(RTMP_HEADER - rt->flv_header_bytes, size_temp);
2676  int channel = RTMP_AUDIO_CHANNEL;
2677  bytestream_get_buffer(&buf_temp, rt->flv_header + rt->flv_header_bytes, copy);
2678  rt->flv_header_bytes += copy;
2679  size_temp -= copy;
2680  if (rt->flv_header_bytes < RTMP_HEADER)
2681  break;
2682 
2683  pkttype = bytestream_get_byte(&header);
2684  pktsize = bytestream_get_be24(&header);
2685  ts = bytestream_get_be24(&header);
2686  ts |= bytestream_get_byte(&header) << 24;
2687  bytestream_get_be24(&header);
2688  rt->flv_size = pktsize;
2689 
2690  if (pkttype == RTMP_PT_VIDEO)
2691  channel = RTMP_VIDEO_CHANNEL;
2692 
2693  //force 12bytes header
2694  if (((pkttype == RTMP_PT_VIDEO || pkttype == RTMP_PT_AUDIO) && ts == 0) ||
2695  pkttype == RTMP_PT_NOTIFY) {
2696  if (pkttype == RTMP_PT_NOTIFY)
2697  pktsize += 16;
2698  if ((ret = ff_rtmp_check_alloc_array(&rt->prev_pkt[1],
2699  &rt->nb_prev_pkt[1],
2700  channel)) < 0)
2701  return ret;
2702  rt->prev_pkt[1][channel].channel_id = 0;
2703  }
2704 
2705  //this can be a big packet, it's better to send it right here
2706  if ((ret = ff_rtmp_packet_create(&rt->out_pkt, channel,
2707  pkttype, ts, pktsize)) < 0)
2708  return ret;
2709 
2710  rt->out_pkt.extra = rt->stream_id;
2711  rt->flv_data = rt->out_pkt.data;
2712 
2713  if (pkttype == RTMP_PT_NOTIFY)
2714  ff_amf_write_string(&rt->flv_data, "@setDataFrame");
2715  }
2716 
2717  if (rt->flv_size - rt->flv_off > size_temp) {
2718  bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, size_temp);
2719  rt->flv_off += size_temp;
2720  size_temp = 0;
2721  } else {
2722  bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, rt->flv_size - rt->flv_off);
2723  size_temp -= rt->flv_size - rt->flv_off;
2724  rt->flv_off += rt->flv_size - rt->flv_off;
2725  }
2726 
2727  if (rt->flv_off == rt->flv_size) {
2728  rt->skip_bytes = 4;
2729 
2730  if ((ret = rtmp_send_packet(rt, &rt->out_pkt, 0)) < 0)
2731  return ret;
2732  rt->flv_size = 0;
2733  rt->flv_off = 0;
2734  rt->flv_header_bytes = 0;
2735  rt->flv_nb_packets++;
2736  }
2737  } while (buf_temp - buf < size);
2738 
2739  if (rt->flv_nb_packets < rt->flush_interval)
2740  return size;
2741  rt->flv_nb_packets = 0;
2742 
2743  /* set stream into nonblocking mode */
2744  rt->stream->flags |= AVIO_FLAG_NONBLOCK;
2745 
2746  /* try to read one byte from the stream */
2747  ret = ffurl_read(rt->stream, &c, 1);
2748 
2749  /* switch the stream back into blocking mode */
2750  rt->stream->flags &= ~AVIO_FLAG_NONBLOCK;
2751 
2752  if (ret == AVERROR(EAGAIN)) {
2753  /* no incoming data to handle */
2754  return size;
2755  } else if (ret < 0) {
2756  return ret;
2757  } else if (ret == 1) {
2758  RTMPPacket rpkt = { 0 };
2759 
2760  if ((ret = ff_rtmp_packet_read_internal(rt->stream, &rpkt,
2761  rt->in_chunk_size,
2762  &rt->prev_pkt[0],
2763  &rt->nb_prev_pkt[0], c)) <= 0)
2764  return ret;
2765 
2766  if ((ret = rtmp_parse_result(s, rt, &rpkt)) < 0)
2767  return ret;
2768 
2769  ff_rtmp_packet_destroy(&rpkt);
2770  }
2771 
2772  return size;
2773 }
2774 
2775  #define OFFSET(x) offsetof(RTMPContext, x)
2776  #define DEC AV_OPT_FLAG_DECODING_PARAM
2777  #define ENC AV_OPT_FLAG_ENCODING_PARAM
2778 
2779  static const AVOption rtmp_options[] = {
2780  {"rtmp_app", "Name of application to connect to on the RTMP server", OFFSET(app), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2781  {"rtmp_buffer", "Set buffer time in milliseconds. The default is 3000.", OFFSET(client_buffer_time), AV_OPT_TYPE_INT, {.i64 = 3000}, 0, INT_MAX, DEC|ENC},
2782  {"rtmp_conn", "Append arbitrary AMF data to the Connect message", OFFSET(conn), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2783  {"rtmp_flashver", "Version of the Flash plugin used to run the SWF player.", OFFSET(flashver), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2784  {"rtmp_flush_interval", "Number of packets flushed in the same request (RTMPT only).", OFFSET(flush_interval), AV_OPT_TYPE_INT, {.i64 = 10}, 0, INT_MAX, ENC},
2785  {"rtmp_live", "Specify that the media is a live stream.", OFFSET(live), AV_OPT_TYPE_INT, {.i64 = -2}, INT_MIN, INT_MAX, DEC, "rtmp_live"},
2786  {"any", "both", 0, AV_OPT_TYPE_CONST, {.i64 = -2}, 0, 0, DEC, "rtmp_live"},
2787  {"live", "live stream", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, DEC, "rtmp_live"},
2788  {"recorded", "recorded stream", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, DEC, "rtmp_live"},
2789  {"rtmp_pageurl", "URL of the web page in which the media was embedded. By default no value will be sent.", OFFSET(pageurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
2790  {"rtmp_playpath", "Stream identifier to play or to publish", OFFSET(playpath), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2791  {"rtmp_subscribe", "Name of live stream to subscribe to. Defaults to rtmp_playpath.", OFFSET(subscribe), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
2792  {"rtmp_swfhash", "SHA256 hash of the decompressed SWF file (32 bytes).", OFFSET(swfhash), AV_OPT_TYPE_BINARY, .flags = DEC},
2793  {"rtmp_swfsize", "Size of the decompressed SWF file, required for SWFVerification.", OFFSET(swfsize), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC},
2794  {"rtmp_swfurl", "URL of the SWF player. By default no value will be sent", OFFSET(swfurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2795  {"rtmp_swfverify", "URL to player swf file, compute hash/size automatically.", OFFSET(swfverify), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
2796  {"rtmp_tcurl", "URL of the target stream. Defaults to proto://host[:port]/app.", OFFSET(tcurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2797  {"rtmp_listen", "Listen for incoming rtmp connections", OFFSET(listen), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
2798  {"listen", "Listen for incoming rtmp connections", OFFSET(listen), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
2799  {"timeout", "Maximum timeout (in seconds) to wait for incoming connections. -1 is infinite. Implies -rtmp_listen 1", OFFSET(listen_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
2800  { NULL },
2801 };
2802 
2803  #define RTMP_PROTOCOL(flavor) \
2804 static const AVClass flavor##_class = { \
2805  .class_name = #flavor, \
2806  .item_name = av_default_item_name, \
2807  .option = rtmp_options, \
2808  .version = LIBAVUTIL_VERSION_INT, \
2809 }; \
2810  \
2811 URLProtocol ff_##flavor##_protocol = { \
2812  .name = #flavor, \
2813  .url_open = rtmp_open, \
2814  .url_read = rtmp_read, \
2815  .url_read_seek = rtmp_seek, \
2816  .url_write = rtmp_write, \
2817  .url_close = rtmp_close, \
2818  .priv_data_size = sizeof(RTMPContext), \
2819  .flags = URL_PROTOCOL_FLAG_NETWORK, \
2820  .priv_data_class= &flavor##_class, \
2821 };
2822 
2823 
2824 RTMP_PROTOCOL(rtmp)
2825 RTMP_PROTOCOL(rtmpe)
2826 RTMP_PROTOCOL(rtmps)
2827 RTMP_PROTOCOL(rtmpt)
2828 RTMP_PROTOCOL(rtmpte)
2829 RTMP_PROTOCOL(rtmpts)
Generated on Sat Jan 25 2014 19:52:04 for FFmpeg by   doxygen 1.8.2

AltStyle によって変換されたページ (->オリジナル) /