low-can-binding/utils/socketcan-j1939.cpp

   1 /*
   2  * Copyright (C) 2018, 2019 "IoT.bzh"
   3  * Author "Arthur Guyader" <arthur.guyader@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <net/if.h>
  19 #include <sys/ioctl.h>
  20 #include <fcntl.h>
  21 #include "./socketcan-j1939.hpp"
  22 #include "../binding/application.hpp"
  23
  24 namespace utils
  25 {
  26         /// @brief Connect the socket.
  27         /// @return 0 if success.
  28         int socketcan_j1939_t::connect(const struct sockaddr* addr, socklen_t len)
  29         {
  30                 return socket_ != INVALID_SOCKET ? ::connect(socket_, addr, len) : 0;
  31         }
  32
  33         /// @brief Bind the socket.
  34         /// @return 0 if success.
  35         int socketcan_j1939_t::bind(const struct sockaddr* addr, socklen_t len)
  36         {
  37                 return socket_ != INVALID_SOCKET ? ::bind(socket_, addr, len) : 0;
  38         }
  39
  40         void socketcan_j1939_t::filter(name_t name, pgn_t pgn, uint8_t addr, uint64_t name_mask, uint32_t pgn_mask, uint8_t addr_mask)
  41         {
  42                 int filter_on = 0;
  43                 struct j1939_filter filter;
  44                 memset(&filter, 0, sizeof(filter));
  45                 if (name)
  46                 {
  47                         filter.name = name;
  48                         if(name_mask)
  49                         {
  50                                 filter.name_mask = name_mask;
  51                         } else
  52                         {
  53                                 filter.name_mask = ~0ULL;
  54                         }
  55                         ++filter_on;
  56                 }
  57
  58                 if (addr < 0xff)
  59                 {
  60                         filter.addr = addr;
  61                         if(addr_mask)
  62                         {
  63                                 filter.addr_mask = addr_mask;
  64                         } else
  65                         {
  66                                 filter.addr_mask = ~0;
  67                         }
  68                         ++filter_on;
  69                 }
  70                 if (pgn <= J1939_PGN_MAX)
  71                 {
  72                         filter.pgn = pgn;
  73                         if(pgn_mask)
  74                         {
  75                                 filter.pgn_mask = pgn_mask;
  76                         } else
  77                         {
  78                                 filter.pgn_mask = ~0;
  79                         }
  80                         ++filter_on;
  81                 }
  82                 if(filter_on)
  83                 {
  84                         setopt(SOL_CAN_J1939, SO_J1939_FILTER, &filter, sizeof(filter));
  85                 }
  86         }
  87
  88         int socketcan_j1939_t::open(std::string device_name)
  89         {
  90                 return open(device_name,0,0,0);
  91         }
  92
  93         int socketcan_j1939_t::open(std::string device_name,  name_t name, pgn_t pgn, uint8_t addr)
  94         {
  95
  96                 struct ifreq ifr;
  97                 socket_ = socketcan_t::open(PF_CAN, SOCK_DGRAM, CAN_J1939);
  98
  99                 // Attempts to open a socket to CAN bus
 100                 ::strcpy(ifr.ifr_name, device_name.c_str());
 101                 AFB_DEBUG("ifr_name is : %s", ifr.ifr_name);
 102                 if(::ioctl(socket_, SIOCGIFINDEX, &ifr) < 0)
 103                 {
 104                         AFB_ERROR("ioctl failed. Error was : %s", strerror(errno));
 105                         close();
 106                 }
 107                 else
 108                 {
 109                         tx_address_.can_family = AF_CAN;
 110                         tx_address_.can_ifindex = ifr.ifr_ifindex;
 111
 112                         if(addr <= 0 || addr >= UINT8_MAX )
 113                         {
 114                                 tx_address_.can_addr.j1939.addr = J1939_NO_ADDR;
 115                         }
 116                         else
 117                         {
 118                                 tx_address_.can_addr.j1939.addr = addr;
 119                         }
 120
 121                         if(name <= 0 || name >= UINT64_MAX )
 122                         {
 123                                 tx_address_.can_addr.j1939.name = J1939_NO_NAME;
 124                         }
 125                         else
 126                         {
 127                                 tx_address_.can_addr.j1939.name = name;
 128                         }
 129
 130                         if(pgn <= 0 || pgn > J1939_PGN_MAX)
 131                         {
 132                                 tx_address_.can_addr.j1939.pgn = J1939_NO_PGN;
 133                         }
 134                         else
 135                         {
 136                                 tx_address_.can_addr.j1939.pgn = pgn;
 137                         }
 138
 139                         if(bind((struct sockaddr *)&tx_address_, sizeof(tx_address_)) < 0)
 140                         {
 141                                 AFB_ERROR("Bind failed. %s", strerror(errno));
 142                                 close();
 143                         }
 144                         else
 145                         {
 146                                 int promisc = 1; // 0 = disabled (default), 1 = enabled
 147                                 setopt(SOL_CAN_J1939, SO_J1939_PROMISC, &promisc, sizeof(promisc));
 148                                 int recv_own_msgs = 1; // 0 = disabled (default), 1 = enabled
 149                                 setopt(SOL_CAN_J1939, SO_J1939_RECV_OWN, &recv_own_msgs, sizeof(recv_own_msgs));
 150                                 if(tx_address_.can_addr.j1939.pgn != J1939_NO_PGN)
 151                                 {
 152                                         filter(J1939_NO_NAME,tx_address_.can_addr.j1939.pgn,J1939_NO_ADDR);
 153                                 }
 154                         }
 155                 }
 156                 return socket_;
 157         }
 158
 159         std::shared_ptr<message_t> socketcan_j1939_t::read_message()
 160         {
 161                 std::shared_ptr<j1939_message_t> jm = std::make_shared<j1939_message_t>();
 162                 uint8_t data[128] = {0};
 163
 164                 struct sockaddr_can addr;
 165                 socklen_t addrlen = sizeof(addr);
 166                 struct ifreq ifr;
 167
 168                 ssize_t nbytes = ::recvfrom(socket(), &data, sizeof(data), 0, (struct sockaddr*)&addr, &addrlen);
 169                 ifr.ifr_ifindex = get_tx_address().can_ifindex;
 170                 ioctl(socket(), SIOCGIFNAME, &ifr);
 171
 172                 AFB_DEBUG("Data available: %i bytes read", (int)nbytes);
 173                 /*AFB_DEBUG("read: Found on bus %s:\n id: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X", ifr.ifr_name, frame.can_id, frame.len,
 174                         data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);*/
 175
 176                 struct timeval tv;
 177                 ioctl(socket(), SIOCGSTAMP, &tv);
 178                 uint64_t timestamp = 1000000 * tv.tv_sec + tv.tv_usec;
 179                 jm = j1939_message_t::convert_from_addr(addr, data , nbytes, timestamp);
 180                 jm->set_sub_id((int)socket());
 181                 return jm;
 182         }
 183
 184
 185         void socketcan_j1939_t::write_message(std::vector<std::shared_ptr<message_t>>& vobj)
 186         {
 187                 AFB_WARNING("Not implemented");
 188         }
 189
 190         void socketcan_j1939_t::write_message(std::shared_ptr<message_t> cm)
 191         {
 192                 AFB_WARNING("Not implemented");
 193         }
 194
 195 }