Peter M. Groen / libmodbus

Commit e7d499b61a6307ea4046af3915fee73980ec938a

Authored by Stéphane Raimbault
1 parent a0b12254

Allow 0 size in mapping allocation 

Idea suggested by Hannu Vuolasaho
Inline Side-by-side
Showing 1 changed file with 48 additions and 34 deletions
src/modbus.c
  View file @e7d499b
... ... @@ -2036,53 +2036,67 @@ modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits,
2036 2036  
2037 2037 /* 0X */
2038 2038 mb_mapping->nb_bits = nb_bits;
2039   - mb_mapping->tab_bits =
2040   - (uint8_t *) malloc(nb_bits * sizeof(uint8_t));
2041   - if (mb_mapping->tab_bits == NULL) {
2042   - free(mb_mapping);
2043   - return NULL;
  2039 + if (nb_bits == 0) {
  2040 + mb_mapping->tab_bits = NULL;
  2041 + } else {
  2042 + /* Negative number raises a POSIX error */
  2043 + mb_mapping->tab_bits =
  2044 + (uint8_t *) malloc(nb_bits * sizeof(uint8_t));
  2045 + if (mb_mapping->tab_bits == NULL) {
  2046 + free(mb_mapping);
  2047 + return NULL;
  2048 + }
  2049 + memset(mb_mapping->tab_bits, 0, nb_bits * sizeof(uint8_t));
2044 2050 }
2045   - memset(mb_mapping->tab_bits, 0,
2046   - nb_bits * sizeof(uint8_t));
2047 2051  
2048 2052 /* 1X */
2049 2053 mb_mapping->nb_input_bits = nb_input_bits;
2050   - mb_mapping->tab_input_bits =
2051   - (uint8_t *) malloc(nb_input_bits * sizeof(uint8_t));
2052   - if (mb_mapping->tab_input_bits == NULL) {
2053   - free(mb_mapping);
2054   - free(mb_mapping->tab_bits);
2055   - return NULL;
  2054 + if (nb_input_bits == 0) {
  2055 + mb_mapping->tab_input_bits = NULL;
  2056 + } else {
  2057 + mb_mapping->tab_input_bits =
  2058 + (uint8_t *) malloc(nb_input_bits * sizeof(uint8_t));
  2059 + if (mb_mapping->tab_input_bits == NULL) {
  2060 + free(mb_mapping);
  2061 + free(mb_mapping->tab_bits);
  2062 + return NULL;
  2063 + }
  2064 + memset(mb_mapping->tab_input_bits, 0, nb_input_bits * sizeof(uint8_t));
2056 2065 }
2057   - memset(mb_mapping->tab_input_bits, 0,
2058   - nb_input_bits * sizeof(uint8_t));
2059 2066  
2060 2067 /* 4X */
2061 2068 mb_mapping->nb_registers = nb_registers;
2062   - mb_mapping->tab_registers =
2063   - (uint16_t *) malloc(nb_registers * sizeof(uint16_t));
2064   - if (mb_mapping->tab_registers == NULL) {
2065   - free(mb_mapping);
2066   - free(mb_mapping->tab_bits);
2067   - free(mb_mapping->tab_input_bits);
2068   - return NULL;
  2069 + if (nb_registers == 0) {
  2070 + mb_mapping->tab_registers = NULL;
  2071 + } else {
  2072 + mb_mapping->tab_registers =
  2073 + (uint16_t *) malloc(nb_registers * sizeof(uint16_t));
  2074 + if (mb_mapping->tab_registers == NULL) {
  2075 + free(mb_mapping);
  2076 + free(mb_mapping->tab_bits);
  2077 + free(mb_mapping->tab_input_bits);
  2078 + return NULL;
  2079 + }
  2080 + memset(mb_mapping->tab_registers, 0, nb_registers * sizeof(uint16_t));
2069 2081 }
2070   - memset(mb_mapping->tab_registers, 0,
2071   - nb_registers * sizeof(uint16_t));
2072 2082  
2073 2083 /* 3X */
2074 2084 mb_mapping->nb_input_registers = nb_input_registers;
2075   - mb_mapping->tab_input_registers =
2076   - (uint16_t *) malloc(nb_input_registers * sizeof(uint16_t));
2077   - if (mb_mapping->tab_input_registers == NULL) {
2078   - free(mb_mapping);
2079   - free(mb_mapping->tab_bits);
2080   - free(mb_mapping->tab_input_bits);
2081   - free(mb_mapping->tab_registers);
2082   - return NULL;
  2085 + if (nb_input_registers == 0) {
  2086 + mb_mapping->tab_input_registers = NULL;
  2087 + } else {
  2088 + mb_mapping->tab_input_registers =
  2089 + (uint16_t *) malloc(nb_input_registers * sizeof(uint16_t));
  2090 + if (mb_mapping->tab_input_registers == NULL) {
  2091 + free(mb_mapping);
  2092 + free(mb_mapping->tab_bits);
  2093 + free(mb_mapping->tab_input_bits);
  2094 + free(mb_mapping->tab_registers);
  2095 + return NULL;
  2096 + }
  2097 + memset(mb_mapping->tab_input_registers, 0,
  2098 + nb_input_registers * sizeof(uint16_t));
2083 2099 }
2084   - memset(mb_mapping->tab_input_registers, 0,
2085   - nb_input_registers * sizeof(uint16_t));
2086 2100  
2087 2101 return mb_mapping;
2088 2102 }
... ...