Esempio n. 1
0
static size_t
readPacket (BrailleDisplay *brl, InputPacket *packet) {
  const size_t length = 10;
  size_t offset = 0;

  while (1) {
    unsigned char byte;

    {
      int started = offset > 0;
      if (!gioReadByte(brl->gioEndpoint, &byte, started)) {
        if (started) logPartialPacket(packet->bytes, offset);
        return 0;
      }
    }

    if (!offset) {
      if (byte != 0XFA) {
        logIgnoredByte(byte);
        continue;
      }
    }

    packet->bytes[offset++] = byte;
    if (offset == length) {
      if (byte == 0XFB) {
        {
          int checksum = -packet->data.checksum;

          {
            size_t i;
            for (i=0; i<offset; i+=1) checksum += packet->bytes[i];
          }

          if ((checksum & 0XFF) != packet->data.checksum) {
            logInputProblem("Incorrect Input Checksum", packet->bytes, offset);
          }
        }

        logInputPacket(packet->bytes, offset);
        return length;
      }

      {
        const unsigned char *start = memchr(packet->bytes+1, packet->bytes[0], offset-1);
        const unsigned char *end = packet->bytes + offset;
        if (!start) start = end;
        logDiscardedBytes(packet->bytes, start-packet->bytes);
        memmove(packet->bytes, start, (offset = end - start));
      }
    }
  }
}
Esempio n. 2
0
static BraillePacketVerifierResult
verifyPacket (
  BrailleDisplay *brl,
  const unsigned char *bytes, size_t size,
  size_t *length, void *data
) {
  unsigned char byte = bytes[size-1];

  switch (size) {
    case 1: {
      switch (byte) {
        case 0XFA:
          *length = 10;
          break;

        default:
          return BRL_PVR_INVALID;
      }

      break;
    }

    default:
      break;
  }

  if (size == *length) {
    switch (bytes[0]) {
      case 0XFA: {
        if (byte != 0XFB) return BRL_PVR_INVALID;

        const InputPacket *packet = (const void *)bytes;
        int checksum = -packet->fields.checksum;
        for (size_t i=0; i<size; i+=1) checksum += packet->bytes[i];

        if ((checksum & 0XFF) != packet->fields.checksum) {
          logInputProblem("incorrect input checksum", packet->bytes, size);
          return BRL_PVR_INVALID;
        }

        break;
      }

      default:
        break;
    }
  }

  return BRL_PVR_INCLUDE;
}
Esempio n. 3
0
void
logDiscardedBytes (const unsigned char *bytes, size_t count) {
  logInputProblem("Discarded Bytes", bytes, count);
}
Esempio n. 4
0
void
logCorruptPacket (const void *packet, size_t size) {
  logInputProblem("Corrupt Packet", packet, size);
}
Esempio n. 5
0
void
logUnexpectedPacket (const void *packet, size_t size) {
  logInputProblem("Unexpected Packet", packet, size);
}
Esempio n. 6
0
void
logShortPacket (const void *packet, size_t size) {
  logInputProblem("Short Packet", packet, size);
}
Esempio n. 7
0
void
logTruncatedPacket (const void *packet, size_t size) {
  logInputProblem("Truncated Packet", packet, size);
}
Esempio n. 8
0
void
logPartialPacket (const void *packet, size_t size) {
  logInputProblem("Partial Packet", packet, size);
}
Esempio n. 9
0
void
logUnknownPacket (unsigned char byte) {
  logInputProblem("Unknown Packet", &byte, 1);
}
Esempio n. 10
0
void
logDiscardedByte (unsigned char byte) {
  logInputProblem("Discarded Byte", &byte, 1);
}
Esempio n. 11
0
void
logIgnoredByte (unsigned char byte) {
  logInputProblem("Ignored Byte", &byte, 1);
}