Lines Matching defs:head

455         // is size more than one head

464             // nothing need to send, this is a head only package

521     // if we have at least one byte, we think there should be a head

579     UartHead *head = reinterpret_cast<UartHead *>(data);

581               head->ToDebugString().c_str(), *(data + sizeof(UartHead)),

585     if (head->sessionId != hSession->sessionId) {

588                       head->sessionId);

589             SendUartSoftReset(hSession, head->sessionId);

596         hSession->hUART->streamSize += head->dataSize; // this is only for debug,

600                               data + sizeof(UartHead), head->dataSize) < 0) {

627 package is divided into head and data

661     UartHead *head = reinterpret_cast<UartHead *>(data);

662     bool response = head->IsResponsePackage();

665         slots.Wait(head->sessionId);

670     std::string pkgId = head->ToPkgIdentityString(response);

673         // update che checksum , both head and data

674         head->UpdateCheckSum();

675         outPkgs.emplace_back(pkgId, head->sessionId, data, length, response,

676                              head->option & PKG_OPTION_ACK);

678                   head->ToDebugString().c_str(), outPkgs.size());

681                   head->ToDebugString().c_str(), pkgId.c_str());

686 void HdcUARTBase::ProcessResponsePackage(const UartHead &head)

689     bool ack = head.option & PKG_OPTION_ACK;

691     std::string pkgId = head.ToPkgIdentityString();

829     struct UartHead *head = (struct UartHead *)data.data();

830     WRITE_LOG(LOG_DEBUG, "%s %s", __FUNCTION__, head->ToDebugString().c_str());

832     if (memcmp(head->flag, PACKET_FLAG.c_str(), PACKET_FLAG.size()) != 0) {

833         WRITE_LOG(LOG_FATAL, "%s,PACKET_FLAG not correct %x %x", __FUNCTION__, head->flag[0],

834                   head->flag[1]);

838     if (!head->ValidateHead()) {

839         WRITE_LOG(LOG_FATAL, "%s head checksum not correct", __FUNCTION__);

843     sessionId = head->sessionId;

844     packetSize = head->dataSize + sizeof(UartHead);

845     packageIndex = head->packageIndex;

847     if ((head->dataSize + sizeof(UartHead)) > MAX_UART_SIZE_IOBUF * maxBufFactor) {

848         WRITE_LOG(LOG_FATAL, "%s dataSize too larger:%d", __FUNCTION__, head->dataSize);

852     if ((head->option & PKG_OPTION_RESET)) {

855                   __FUNCTION__, head->sessionId);

856         ResetOldSession(head->sessionId);

860     if ((head->option & PKG_OPTION_FREE)) {

864                   head->sessionId);

865         Restartession(GetSession(head->sessionId));

871         if (!head->ValidateData()) {

875         if (head->IsResponsePackage()) {

877             ProcessResponsePackage(*head);

880             ResponseUartTrans(head->sessionId, head->packageIndex, PKG_OPTION_ACK);

906         UartHead *head = (UartHead *)sendDataBuf;

907         if (memset_s(head, sizeof(UartHead), 0, sizeof(UartHead)) != EOK) {

910         if (memcpy_s(head->flag, sizeof(head->flag), PACKET_FLAG.c_str(), PACKET_FLAG.size()) !=

914         head->sessionId = hSession->sessionId;

915         head->packageIndex = ++hSession->hUART->packageIndex;

920             head->dataSize = static_cast<uint16_t>(packageDataMaxSize);

923             head->dataSize = static_cast<uint16_t>(RemainingDataSize);

925             head->option = head->option | PKG_OPTION_TAIL;

932             memcpy_s(payload, packageDataMaxSize, (uint8_t *)data + offset, head->dataSize)) {

934                       packageDataMaxSize, head->dataSize);

937         offset += head->dataSize;

938         int packageFullSize = sizeof(UartHead) + head->dataSize;

939         WRITE_LOG(LOG_ALL, "SendUARTData =============> %s", head->ToDebugString().c_str());