parse_args.c

这个程序实现了FLUTE协议

      else if(a->alc_a.addr_family == PF_INET6) {
	tmp_addr = DEF_MCAST_IPv6_ADDR;
      }
    }
    a->alc_a.addr = tmp_addr;
    
    if(fec_enc == 1) {
      a->alc_a.fec_enc_id = SIMPLE_XOR_FEC_ENC_ID;
      
      if(a->alc_a.addr_family == PF_INET) {
	a->alc_a.es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_128_129;
      }
      else if(a->alc_a.addr_family == PF_INET6) {
	a->alc_a.es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_128_129;
      }
    }
    else if(fec_enc == 2) {
      a->alc_a.fec_enc_id = SB_SYS_FEC_ENC_ID;
      a->alc_a.fec_inst_id = REED_SOL_FEC_INST_ID;
      
      if(a->alc_a.addr_family == PF_INET) {
	a->alc_a.es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_128_129;
      }
      else if(a->alc_a.addr_family == PF_INET6) {
	a->alc_a.es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_128_129;
      }
    }
    
    if(a->alc_a.mode == RECEIVER) {
      a->alc_a.tsi = tmp_tsi;
      
      memset(a->alc_a.base_dir, 0, MAX_LENGTH);
      
      if(tmp_base_dir == NULL) {
	strcpy(a->alc_a.base_dir, DEF_BASE_DIR);
      }
      else {
	strcpy(a->alc_a.base_dir, tmp_base_dir);
      }
      
      a->alc_a.start_time = curr_time;
      a->alc_a.stop_time = 0;
    }
    else {
      if(((a->alc_a.half_word == false) && (tmp_tsi > 0xFFFFFFFF))) {
	printf("TSI too big for unsigned long (32 bits)\n");
	fflush(stdout);
	return -1;
      }
      else {
	a->alc_a.tsi = tmp_tsi;
      }
      
      memset(a->alc_a.base_dir, 0, MAX_LENGTH);
      
      if(tmp_base_dir != NULL) {
	strcpy(a->alc_a.base_dir, tmp_base_dir);
      }
      
      a->alc_a.start_time = curr_time;
      a->alc_a.stop_time = curr_time + duration;
    }
    
    if(tmp_max_sb_len != 0) {
      if(a->alc_a.fec_enc_id == COM_NO_C_FEC_ENC_ID) {
	
	if(tmp_max_sb_len > MAX_SB_LEN_NULL_FEC) {
	  printf("Maximum source block length set to maximum value: %i\n", MAX_SB_LEN_NULL_FEC);
	  fflush(stdout);
	  tmp_max_sb_len = MAX_SB_LEN_NULL_FEC;
	}
	a->alc_a.max_sb_len = tmp_max_sb_len;
      }
      
      else if(a->alc_a.fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) {
	if(tmp_max_sb_len > MAX_SB_LEN_SIMPLE_XOR_FEC) {
	  printf("Maximum source block length set to maximum value: %i\n", MAX_SB_LEN_SIMPLE_XOR_FEC);
	  fflush(stdout);
	  tmp_max_sb_len = MAX_SB_LEN_SIMPLE_XOR_FEC;
	}
	a->alc_a.max_sb_len = tmp_max_sb_len;
      }
      
      else if(((a->alc_a.fec_enc_id == SB_SYS_FEC_ENC_ID) && (a->alc_a.fec_inst_id == REED_SOL_FEC_INST_ID))) {
	
	div_max_n = div((tmp_max_sb_len * (100 + a->alc_a.fec_ratio)), 100);
	
	if(div_max_n.quot > MAX_N_REED_SOLOMON) {
	  
	  div_max_k = div((MAX_N_REED_SOLOMON * 100), (100 + a->alc_a.fec_ratio));
	  
	  printf("Maximum source block length set to maximum value: %i\n", div_max_k.quot);
	  fflush(stdout);
	  tmp_max_sb_len = div_max_k.quot;
	}
	a->alc_a.max_sb_len = tmp_max_sb_len;
      }
    }
    
    if(tmp_es_len != 0) {
      if(a->alc_a.addr_family == PF_INET) {
	if(((a->alc_a.fec_enc_id == COM_NO_C_FEC_ENC_ID) || (a->alc_a.fec_enc_id == COM_FEC_ENC_ID))) {
	  if(tmp_es_len > MAX_SYMB_LENGTH_IPv4_FEC_ID_0_130) {
	    printf("Encoding symbol length set to maximum value: %i\n",
		   MAX_SYMB_LENGTH_IPv4_FEC_ID_0_130);
	    fflush(stdout);
	    tmp_es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_0_130;
	  }
	}
	else if(((a->alc_a.fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) ||
		 (a->alc_a.fec_enc_id == SB_LB_E_FEC_ENC_ID) ||
		 (a->alc_a.fec_enc_id == SB_SYS_FEC_ENC_ID))) {
	  if(tmp_es_len > MAX_SYMB_LENGTH_IPv4_FEC_ID_128_129) {
	    printf("Encoding symbol length set to maximum value: %i\n",
		   MAX_SYMB_LENGTH_IPv4_FEC_ID_128_129);
	    fflush(stdout);
	    tmp_es_len = MAX_SYMB_LENGTH_IPv4_FEC_ID_128_129;
	  }	
	}
      }
      else if(a->alc_a.addr_family == PF_INET6) {	
	if(((a->alc_a.fec_enc_id == COM_NO_C_FEC_ENC_ID) || (a->alc_a.fec_enc_id == COM_FEC_ENC_ID))) {
	  if(tmp_es_len > MAX_SYMB_LENGTH_IPv6_FEC_ID_0_130) {
	    printf("Encoding symbol length set to maximum value: %i\n",
		   MAX_SYMB_LENGTH_IPv6_FEC_ID_0_130);
	    fflush(stdout);
	    tmp_es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_0_130;
	  }
	}
	else if(((a->alc_a.fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) ||
		 (a->alc_a.fec_enc_id == SB_LB_E_FEC_ENC_ID) ||
		 (a->alc_a.fec_enc_id == SB_SYS_FEC_ENC_ID))) {
	  if(tmp_es_len > MAX_SYMB_LENGTH_IPv6_FEC_ID_128_129) {
	    printf("Encoding symbol length set to maximum value: %i\n",
		   MAX_SYMB_LENGTH_IPv6_FEC_ID_128_129);
	    fflush(stdout);
	    tmp_es_len = MAX_SYMB_LENGTH_IPv6_FEC_ID_128_129;
	  }	
	}
      }
      
      a->alc_a.es_len = tmp_es_len;
    }
    
    return 0;
  }

/*
 * This function parse session information from SDP file.
 *
 * Params:	arguments_t *a: Pointer to arguments structure where command line arguments are parsed.
 *              char addrs[MAX_CHANNELS_IN_SESSION][MAX_LENGTH]:,
 *              char ports[MAX_CHANNELS_IN_SESSION][MAX_LENGTH]:,
 *              char *sdp_buf:.
 *
 * Return:	int: 0 in success, -1 otherwise
 *
 */

int parse_sdp_file(arguments_t *a, char addrs[MAX_CHANNELS_IN_SESSION][MAX_LENGTH],
				   char ports[MAX_CHANNELS_IN_SESSION][MAX_LENGTH], char *sdp_buf) {

	int i;
	int flute_ch_number;
	int m_lines = 0;
	int j = 0;
	int number_of_port;
	int port;
	int number_of_address;
	char *address;
	int nb_of_accepted_ch = 0;
	int nb_of_defined_ch = 0;
	struct sockaddr_in ipv4;
	unsigned long addr_nb = 0;
	unsigned short ipv6addr[8];
	int nb_ipv6_part;
	int dup_sep = 0;
	char tmp[5];
	int k, l, m;
	int retcode = 0;
	int position = 0;

	char *start_time = NULL;
	char *stop_time = NULL;
	int errno;

#ifndef WIN32
	char *ep;
#endif

	fec_dec_t *fec_dec;
	fec_dec_t *current_fec_dec;
	int m_line_att_pos;
	char *att_name;
	char *att_value;
	bool supported_fec = false;
	bool fec_inst_exists = false;

	sdp_init(&a->sdp);

	if(sdp_parse(a->sdp, sdp_buf) != 0) {
	  printf("Error: sdp_parse()\n");
	  fflush(stdout);
	  free(sdp_buf);
	  sdp_free(a->sdp);
	  return -1;
	}

	a->src_filt = sf_char2struct(sdp_attr_get(a->sdp, "source-filter"));
	
	a->alc_a.src_addr = a->src_filt->src_addr;
	a->alc_a.tsi = (unsigned int)atoi(sdp_attr_get(a->sdp, "flute-tsi"));

	/* Default channel number is one and it is overwrited if there is
	   'a:flute-ch' in the SDP file. */

	flute_ch_number = 1;
	
	if(sdp_attr_get(a->sdp, "flute-ch") != NULL) {
		flute_ch_number = (unsigned int)atoi(sdp_attr_get(a->sdp, "flute-ch"));
	}

	if(strcmp(sdp_c_addrtype_get(a->sdp, 0, 0), "IP4") == 0) {
		a->alc_a.addr_family = PF_INET;
	}
	else if(strcmp(sdp_c_addrtype_get(a->sdp, 0, 0), "IP6") == 0) {
		a->alc_a.addr_family = PF_INET6;
	}

	/* fetch session starttime */

	start_time = sdp_t_start_time_get (a->sdp, 0);

	if(start_time != NULL) {
#ifdef WIN32			  
		a->alc_a.start_time = _atoi64(start_time);

		if(a->alc_a.start_time > (ULONGLONG)0xFFFFFFFFFFFFFFFF) {
			printf("Error: Invalid SDP, start time too big.\n");
			fflush(stdout);
			free(sdp_buf);

			sf_free(a->src_filt);
			free(a->src_filt);
			sdp_free(a->sdp);
			free(a->sdp);

			return -1;
		}
#else				
		a->alc_a.start_time = strtoull(start_time, &ep, 10);

        if(errno == ERANGE && a->alc_a.start_time == 0xFFFFFFFFFFFFFFFFULL) {
            printf("Error: Invalid SDP, start time too big.\n");
			fflush(stdout);
			free(sdp_buf);

			sf_free(a->src_filt);
			free(a->src_filt);
			sdp_free(a->sdp);
			free(a->sdp);

			return -1;
        }
#endif	
	}
	
	/* fetch session stoptime */

	stop_time = sdp_t_stop_time_get (a->sdp, 0);

	if(stop_time != NULL) {
#ifdef WIN32			  
		a->alc_a.stop_time = _atoi64(stop_time);

		if(a->alc_a.stop_time > (ULONGLONG)0xFFFFFFFFFFFFFFFF) {
			printf("Error: Invalid SDP, stop time too big.\n");
			fflush(stdout);
			free(sdp_buf);

			sf_free(a->src_filt);
			free(a->src_filt);
			sdp_free(a->sdp);
			free(a->sdp);

			return -1;
		}
#else				
		a->alc_a.stop_time = strtoull(stop_time, &ep, 10);

        if(errno == ERANGE && a->alc_a.stop_time == 0xFFFFFFFFFFFFFFFFULL) {
            printf("Error: Invalid SDP, stop time too big.\n");
			fflush(stdout);
			free(sdp_buf);

			sf_free(a->src_filt);
			free(a->src_filt);
			sdp_free(a->sdp);
			free(a->sdp);

			return -1;
        }
#endif
	/*
		if(a->alc_a.stop_time == 0) {
			a->cont = true;
		}
	*/
	}
	
	/* Session level FEC declaration */
	fec_dec = sdp_fec_dec_get(a->sdp);

	/* Search how many m-lines is defined in SDP */

	while(1) {
		if(sdp_endof_media(a->sdp, position) == 0) {

			/* check that 'proto' field is FLUTE/UDP */
			if(strcmp(sdp_m_proto_get(a->sdp, position), "FLUTE/UDP") == 0) {

				/* check that payload number exists */
				if(sdp_m_payload_get(a->sdp, position, 0) != NULL) {
					m_lines++;
				}
			}

			position++;
		}
		else {
			break;
		}
	}

	if(m_lines == 0) {
		printf("Error: Invalid SDP, no valid 'm' field.\n");
		fflush(stdout);
		free(sdp_buf);

		sf_free(a->src_filt);
		free(a->src_filt);
		sdp_free(a->sdp);
		free(a->sdp);

		return -1;
	}

	for(i = 0; i < m_lines; i++) {

		m_line_att_pos = 0;

		while((att_name = sdp_a_att_field_get(a->sdp, i, m_line_att_pos)) != NULL) {
			if(strcmp(att_name, "FEC") == 0) {
				fec_inst_exists = true;
				att_value = sdp_a_att_value_get(a->sdp, i, m_line_att_pos);
				
				if(fec_dec == NULL) {
					printf("Error: Invalid SDP, FEC-declaration does not exists.\n");
					fflush(stdout);
					free(sdp_buf);

					sf_free(a->src_filt);
					free(a->src_filt);
					sdp_free(a->sdp);
					free(a->sdp);

					return -1;
				}

				current_fec_dec = fec_dec;

				while(current_fec_dec != NULL) {

					if(current_fec_dec->index == atoi(att_value)) {
							
						if(current_fec_dec->fec_enc_id == COM_NO_C_FEC_ENC_ID) {
							a->alc_a.fec_enc_id = COM_NO_C_FEC_ENC_ID;
							a->alc_a.fec_inst_id = 0;
							supported_fec = true;
						}
						if(current_fec_dec->fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) {
							a->alc_a.fec_enc_id = SIMPLE_XOR_FEC_ENC_ID;
							a->alc_a.fec_inst_id = 0;
							supported_fec = true;
						}
						if(current_fec_dec->fec_enc_id	== SB_SYS_FEC_ENC_ID &&
							current_fec_dec->fec_inst_id == REED_SOL_FEC_INST_ID) {
							a->alc_a.fec_enc_id = SB_SYS_FEC_ENC_ID;
							a->alc_a.fec_inst_id = REED_SOL_FEC_INST_ID;
							supported_fec = true;
						}
					}
					current_fec_dec = current_fec_dec->next;
				}
			}
			else if(strcmp(att_name, "FEC-declaration") == 0) {
				fec_inst_exists = true;
				att_value = sdp_a_att_value_get(a->sdp, i, m_line_att_pos);
	
				current_fec_dec = fec_dec_char2struct(att_value);
			
				if(current_fec_dec->fec_enc_id == COM_NO_C_FEC_ENC_ID) {
					a->alc_a.fec_enc_id = COM_NO_C_FEC_ENC_ID;
					a->alc_a.fec_inst_id = 0;
					supported_fec = true;
				}
				else if(current_fec_dec->fec_enc_id == SIMPLE_XOR_FEC_ENC_ID) {
					a->alc_a.fec_enc_id = SIMPLE_XOR_FEC_ENC_ID;
					a->alc_a.fec_inst_id = 0;
					supported_fec = true;
				}
				else if(current_fec_dec->fec_enc_id == SB_SYS_FEC_ENC_ID &&
					current_fec_dec->fec_inst_id == REED_SOL_FEC_INST_ID) {
					a->alc_a.fec_enc_id = SB_SYS_FEC_ENC_ID;
					a->alc_a.fec_inst_id = REED_SOL_FEC_INST_ID;
					supported_fec = true;
				}
			}
			m_line_att_pos++;
		}

		if(fec_inst_exists == false) {
			supported_fec = true;
			a->alc_a.fec_enc_id = COM_NO_C_FEC_ENC_ID;
			a->alc_a.fec_inst_id = 0;
		}

		/* how many ports in m-line */

		if(sdp_m_number_of_port_get(a->sdp, i) == NULL) {
			number_of_port = 1;
		}
		else {
			number_of_port = atoi(sdp_m_number_of_port_get(a->sdp, i));
		}
		
		/* how many addresses in c-line */

		if(sdp_c_addr_multicast_int_get(a->sdp, i, 0) == NULL) {
			number_of_address = 1;
		}
		else {
			number_of_address = atoi(sdp_c_addr_multicast_int_get(a->sdp, i, 0));
		}

		if(((number_of_port != 1) && (number_of_address != 1))) {
			printf("Error: Invalid SDP, confusing number of ports and addresses.\n");
			fflush(stdout);
			free(sdp_buf);

			sf_free(a->src_filt);
			free(a->src_filt);
			sdp_free(a->sdp);
			free(a->sdp);

			return -1;
		}
	
		if(number_of_address == 1) {
		
			/* base port number */
			port = atoi(sdp_m_port_get(a->sdp, i));

			for(j = 0; j < number_of_port; j++) {

				if(supported_fec == true) {
					memset(ports[nb_of_accepted_ch], 0, MAX_LENGTH);
					memset(addrs[nb_of_accepted_ch], 0, MAX_LENGTH);

					sprintf(ports[nb_of_accepted_ch], "%i", (port + j));
					strcpy(addrs[nb_of_accepted_ch], sdp_c_addr_get(a->sdp, i, 0));
					nb_of_accepted_ch++;
				}
				nb_of_defined_ch++;
			}
		}
		else if(number_of_port == 1) {
		
			/* base address */
			address = sdp_c_addr_get(a->sdp, i, 0);

			if(a->alc_a.addr_family == PF_INET) {
				/* IPv4 address */
				addr_nb = ntohl(inet_addr(address));
			}
			else if(a->alc_a.addr_family == PF_INET6) {
				/*IPv6 address */
				retcode = ushort_ipv6addr(address, &ipv6addr[0], &nb_ipv6_part);

				if(retcode == -1) {
					free(sdp_buf);

					sf_free(a->src_filt);
					free(a->src_filt);
					sdp_free(a->sdp);
					free(a->sdp);

					return -1;				
				}
			}

			for(j = 0; j < number_of_address; j++) {
				if(supported_fec == true) {
					memset(ports[nb_of_accepted_ch], 0, MAX_LENGTH);
					memset(addrs[nb_of_accepted_ch], 0, MAX_LENGTH);

					strcpy(ports[nb_of_accepted_ch], sdp_m_port_get(a->sdp, i));
					
					if(a->alc_a.addr_family == PF_INET) {
						ipv4.sin_addr.s_addr = htonl(addr_nb + j);
						sprintf(addrs[nb_of_accepted_ch], "%s", inet_ntoa(ipv4.sin_addr));
					}
					else if(a->alc_a.addr_family == PF_INET6) {
						dup_sep = 0;

						for(k = 0; k < nb_ipv6_part + 1; k++) {

							memset(tmp, 0, 5);

							if(ipv6addr[k] != 0) {
								sprintf(tmp, "%x", ipv6addr[k]);
								strcat(addrs[nb_of_accepted_ch], tmp);
							}
							else {
								if(dup_sep == 0) {
									dup_sep = 1;
								}
								else {
									printf("Invalid IPv6 address!\n");
									fflush(stdout);
									free(sdp_buf);

									sf_free(a->src_filt);
									free(a->src_filt);
									sdp_free(a->sdp);
									free(a->sdp);

									return -1;	
								}	
							}

							if(k != nb_ipv6_part) {
								strcat(addrs[nb_of_accepted_ch], ":");
							}
						}

						for(l = nb_ipv6_part;; l--) {

							if(l == 0) {
								printf("Only %i channel possible!\n", (j + 1));
								fflush(stdout);
								free(sdp_buf);

								sf_free(a->src_filt);
								free(a->src_filt);
								sdp_free(a->sdp);
								free(a->sdp);

								return -1;	
							}

							if(ipv6addr[l] + 1 > 0xFFFF) {
								continue;
							}
							
							if(ipv6addr[l] == 0) {

								if(nb_ipv6_part == 7) {
									ipv6addr[l]++;
									break;
								}

								for(m = nb_ipv6_part; m > l; m--) {
									ipv6addr[m + 1] = ipv6addr[m];	
								}

								ipv6addr[l + 1] = 1;

								nb_ipv6_part++;
								break;
							}
							else {
								ipv6addr[l]++;
								break;
							}
						}
					}
				}
				nb_of_defined_ch++;
			}
		}
	}

	if(flute_ch_number != nb_of_defined_ch) {
	  printf("Error: Invalid SDP, channel number not correct.\n");
	  fflush(stdout);
	  free(sdp_buf);

	  sf_free(a->src_filt);
	  free(a->src_filt);
	  sdp_free(a->sdp);
	  free(a->sdp);

	  fec_dec_free(fec_dec);
	  return -1;
	}
	
	a->alc_a.nb_channel = nb_of_accepted_ch;

	free(sdp_buf);
	fec_dec_free(fec_dec);

	return 0;
}