1 #include "config.h" 2 #include "libpldm/transport.h" 3 #include "base.h" 4 #include "libpldm/requester/pldm.h" 5 #include "transport.h" 6 7 #include <errno.h> 8 #include <limits.h> 9 #ifdef PLDM_HAS_POLL 10 #include <poll.h> 11 #endif 12 #include <stdbool.h> 13 #include <stdlib.h> 14 #include <sys/time.h> 15 #include <time.h> 16 #include <unistd.h> 17 18 #ifndef PLDM_HAS_POLL 19 struct pollfd { 20 int fd; /* file descriptor */ 21 short events; /* requested events */ 22 short revents; /* returned events */ 23 }; 24 25 static inline int poll(struct pollfd *fds __attribute__((unused)), 26 int nfds __attribute__((unused)), 27 int timeout __attribute__((unused))) 28 { 29 return 0; 30 } 31 #endif 32 33 LIBPLDM_ABI_TESTING 34 pldm_requester_rc_t pldm_transport_poll(struct pldm_transport *transport, 35 int timeout) 36 { 37 struct pollfd pollfd; 38 int rc = 0; 39 if (!transport) { 40 return PLDM_REQUESTER_INVALID_SETUP; 41 } 42 if (!transport->init_pollfd) { 43 return PLDM_REQUESTER_SUCCESS; 44 } 45 46 transport->init_pollfd(transport, &pollfd); 47 rc = poll(&pollfd, 1, timeout); 48 if (rc < 0) { 49 return PLDM_REQUESTER_POLL_FAIL; 50 } 51 52 return PLDM_REQUESTER_SUCCESS; 53 } 54 55 LIBPLDM_ABI_TESTING 56 pldm_requester_rc_t pldm_transport_send_msg(struct pldm_transport *transport, 57 pldm_tid_t tid, 58 const void *pldm_req_msg, 59 size_t req_msg_len) 60 { 61 if (!transport || !pldm_req_msg) { 62 return PLDM_REQUESTER_INVALID_SETUP; 63 } 64 65 if (req_msg_len < sizeof(struct pldm_msg_hdr)) { 66 return PLDM_REQUESTER_NOT_REQ_MSG; 67 } 68 69 return transport->send(transport, tid, pldm_req_msg, req_msg_len); 70 } 71 72 LIBPLDM_ABI_TESTING 73 pldm_requester_rc_t pldm_transport_recv_msg(struct pldm_transport *transport, 74 pldm_tid_t tid, 75 void **pldm_resp_msg, 76 size_t *resp_msg_len) 77 { 78 if (!transport || !resp_msg_len) { 79 return PLDM_REQUESTER_INVALID_SETUP; 80 } 81 82 pldm_requester_rc_t rc = 83 transport->recv(transport, tid, pldm_resp_msg, resp_msg_len); 84 if (rc != PLDM_REQUESTER_SUCCESS) { 85 return rc; 86 } 87 88 if (*resp_msg_len < sizeof(struct pldm_msg_hdr)) { 89 free(*pldm_resp_msg); 90 *pldm_resp_msg = NULL; 91 return PLDM_REQUESTER_INVALID_RECV_LEN; 92 } 93 return PLDM_REQUESTER_SUCCESS; 94 } 95 96 static void timespec_to_timeval(const struct timespec *ts, struct timeval *tv) 97 { 98 tv->tv_sec = ts->tv_sec; 99 tv->tv_usec = ts->tv_nsec / 1000; 100 } 101 102 /* Overflow safety must be upheld before call */ 103 static long timeval_to_msec(const struct timeval *tv) 104 { 105 return tv->tv_sec * 1000 + tv->tv_usec / 1000; 106 } 107 108 /* If calculations on `tv` don't overflow then operations on derived 109 * intervals can't either. 110 */ 111 static bool timeval_is_valid(const struct timeval *tv) 112 { 113 if (tv->tv_sec < 0 || tv->tv_usec < 0 || tv->tv_usec >= 1000000) { 114 return false; 115 } 116 117 if (tv->tv_sec > (LONG_MAX - tv->tv_usec / 1000) / 1000) { 118 return false; 119 } 120 121 return true; 122 } 123 124 static int clock_gettimeval(clockid_t clockid, struct timeval *tv) 125 { 126 struct timespec now; 127 int rc; 128 129 rc = clock_gettime(clockid, &now); 130 if (rc < 0) { 131 return rc; 132 } 133 134 timespec_to_timeval(&now, tv); 135 136 return 0; 137 } 138 139 LIBPLDM_ABI_TESTING 140 pldm_requester_rc_t 141 pldm_transport_send_recv_msg(struct pldm_transport *transport, pldm_tid_t tid, 142 const void *pldm_req_msg, size_t req_msg_len, 143 void **pldm_resp_msg, size_t *resp_msg_len) 144 145 { 146 /** 147 * Section "Requirements for requesters" in DSP0240, define the Time-out 148 * waiting for a response of the requester. 149 * PT2max = PT3min - 2*PT4max = 4800ms 150 */ 151 static const struct timeval max_response_interval = { 152 .tv_sec = 4, .tv_usec = 800000 153 }; 154 const struct pldm_msg_hdr *req_hdr; 155 struct timeval remaining; 156 pldm_requester_rc_t rc; 157 struct timeval now; 158 struct timeval end; 159 int ret; 160 161 if (req_msg_len < sizeof(*req_hdr) || !resp_msg_len) { 162 return PLDM_REQUESTER_INVALID_SETUP; 163 } 164 165 req_hdr = pldm_req_msg; 166 167 rc = pldm_transport_send_msg(transport, tid, pldm_req_msg, req_msg_len); 168 if (rc != PLDM_REQUESTER_SUCCESS) { 169 return rc; 170 } 171 172 ret = clock_gettimeval(CLOCK_MONOTONIC, &now); 173 if (ret < 0) { 174 return PLDM_REQUESTER_POLL_FAIL; 175 } 176 177 timeradd(&now, &max_response_interval, &end); 178 if (!timeval_is_valid(&end)) { 179 return PLDM_REQUESTER_POLL_FAIL; 180 } 181 182 do { 183 timersub(&end, &now, &remaining); 184 /* 0 <= `timeval_to_msec()` <= 4800, and 4800 < INT_MAX */ 185 rc = pldm_transport_poll(transport, 186 (int)(timeval_to_msec(&remaining))); 187 if (rc != PLDM_REQUESTER_SUCCESS) { 188 return rc; 189 } 190 191 rc = pldm_transport_recv_msg(transport, tid, pldm_resp_msg, 192 resp_msg_len); 193 if (rc == PLDM_REQUESTER_SUCCESS) { 194 const struct pldm_msg_hdr *resp_hdr = *pldm_resp_msg; 195 if (req_hdr->instance_id == resp_hdr->instance_id) { 196 return rc; 197 } 198 199 /* This isn't the message we wanted */ 200 free(*pldm_resp_msg); 201 } 202 203 ret = clock_gettimeval(CLOCK_MONOTONIC, &now); 204 if (ret < 0) { 205 return PLDM_REQUESTER_POLL_FAIL; 206 } 207 } while (!timercmp(&now, &end, <)); 208 209 return PLDM_REQUESTER_RECV_FAIL; 210 } 211