cmtutils.c

安全开发库。含客户端建立ssl连接、签名、证书验证、证书发布和撤销等。编译用到nss

		goto loser;
	}

    /* Obscure the message body */
    rv = SSMObscure_Send(control->obscureObj, message->data, message->len);
    if (rv != 0) {
        goto loser;
    }

	/* Send the message body */
	sent = CMT_WriteThisMany(control, control->sock, (void *)message->data, 
                             message->len);
	if (sent != message->len) {
		goto loser;
	}

    /* Free the buffer */
    free(message->data);
    message->data = NULL;
	return CMTSuccess;

loser:
	return CMTFailure;
}

CMTStatus CMT_ReceiveMessage(PCMT_CONTROL control, CMTItem * response)
{
    CMTMessageHeader header;
    CMUint32 read, rv;

    /* Get the obscured message header */
    read = CMT_ReadThisMany(control, control->sock, 
                            (void *)&header, sizeof(CMTMessageHeader));
    if (read != sizeof(CMTMessageHeader)) {
        goto loser;
    }

    /* Unobscure the message header */
    rv = SSMObscure_Recv(control->obscureObj, &header, sizeof(CMTMessageHeader));
    if (rv != 0) {
        goto loser;
    }

    response->type = ntohl(header.type);
    response->len = ntohl(header.len);
    response->data = (unsigned char *) malloc(response->len);
    if (response->data == NULL) {
        goto loser;
    }

    read = CMT_ReadThisMany(control, control->sock, 
                            (void *)(response->data), response->len); 
    if (read != response->len) {
        goto loser;
    }

    /* Unobscure the message body */
    rv = SSMObscure_Recv(control->obscureObj, response->data, response->len);
    if (rv != 0) {
        goto loser;
    }

#ifdef PRINT_RECEIVE_MESSAGES
    LOG("About to print message received from PSM.\n");
    prettyPrintMessage(response);
#endif /*PRINT_RECEIVE_MESSAGES*/
    return CMTSuccess;
loser:
    if (response->data) {
        free(response->data);
    }
    return CMTFailure;
}

CMUint32 CMT_ReadThisMany(PCMT_CONTROL control, CMTSocket sock, 
                          void * buffer, CMUint32 thisMany)
{
	CMUint32 total = 0;
  
	while (total < thisMany) {
		int got;
		got = control->sockFuncs.recv(sock, (void*)((char*)buffer + total),
                                      thisMany-total);
		if (got < 0 ) {
			break;
		} 
		total += got;
	} 
	return total;
}
 
CMUint32 CMT_WriteThisMany(PCMT_CONTROL control, CMTSocket sock, 
                           void * buffer, CMUint32 thisMany)
{
	CMUint32 total = 0;
  
	while (total < thisMany) {
		CMUint32 got;
		got = control->sockFuncs.send(sock, (void*)((char*)buffer+total), 
                                      thisMany-total);
		if (got < 0) {
			break;
		}
		total += got;
	}
	return total;
}

CMTItem* CMT_ConstructMessage(CMUint32 type, CMUint32 length)
{
    CMTItem * p;

    p = (CMTItem*)malloc(sizeof(CMTItem));
    if (!p) {
	goto loser;
    }

    p->type = type;
    p->len = length;
    p->data = (unsigned char *) malloc(length);
    if (!p->data) {
	goto loser;
    }
    return p;

loser:
    CMT_FreeMessage(p);
    return NULL;
}

void CMT_FreeMessage(CMTItem * p)
{
    if (p != NULL) {
	if (p->data != NULL) {
	    free(p->data);
	}
	free(p);
    }
}

CMTStatus CMT_AddDataConnection(PCMT_CONTROL control, CMTSocket sock, 
                                CMUint32 connectionID)
{
	PCMT_DATA ptr;

	/* This is the first connection */
	if (control->cmtDataConnections == NULL) {
		control->cmtDataConnections = ptr = 
            (PCMT_DATA)calloc(sizeof(CMT_DATA), 1);
		if (!ptr) {
			goto loser;
		}
	} else {
	    /* Position at the last entry */
	    for (ptr = control->cmtDataConnections; (ptr != NULL && ptr->next 
                                                 != NULL); ptr = ptr->next);
		ptr->next = (PCMT_DATA)calloc(sizeof(CMT_DATA), 1);
		if (!ptr->next) {
			goto loser;
		} 
		/* Fix up the pointers */
		ptr->next->previous = ptr;
		ptr = ptr->next;
	}

	/* Fill in the data */
	ptr->sock = sock;
	ptr->connectionID = connectionID;

	return CMTSuccess;
loser:
	return CMTFailure;
}

int
CMT_DestroyDataConnection(PCMT_CONTROL control, CMTSocket sock)
{
    PCMT_DATA ptr, pptr = NULL;
    int rv=CMTSuccess;

    control->sockFuncs.close(sock);
    for (ptr = control->cmtDataConnections; ptr != NULL;
	 pptr = ptr, ptr = ptr->next) {
	if (ptr->sock == sock) {
	    if (pptr == NULL) {
		/* node is at head */
		control->cmtDataConnections = ptr->next;
		if (ptr->priv != NULL)
		    ptr->priv->dest(ptr->priv);
		free(ptr);
		return rv;
	    }
	    /* node is elsewhere */
	    pptr->next = ptr->next;
	    if (ptr->priv != NULL)
	        ptr->priv->dest(ptr->priv);
	    free(ptr);
	    return rv;
	}
    }
    return rv;
}

CMTStatus CMT_CloseDataConnection(PCMT_CONTROL control, CMUint32 connectionID)
{
    /* PCMT_DATA ptr, pptr = NULL; */
    CMTSocket sock;
    /* int rv;*/

    /* Get the socket for this connection */
    if (CMT_GetDataSocket(control, connectionID, &sock) == CMTFailure) {
        goto loser;
    }

    /* Free data connection associated with this socket */
    if (CMT_DestroyDataConnection(control, sock) == CMTFailure) {
        goto loser;
    }

    return CMTSuccess;
loser:
    return CMTFailure;
}

CMTStatus CMT_GetDataConnectionID(PCMT_CONTROL control, CMTSocket sock, CMUint32 * connectionID)
{
	PCMT_DATA ptr;

	for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
		if (ptr->sock == sock) {
			*connectionID = ptr->connectionID;
			return CMTSuccess;
		}
	}

	return CMTFailure;
}

CMTStatus CMT_GetDataSocket(PCMT_CONTROL control, CMUint32 connectionID, CMTSocket * sock)
{
	PCMT_DATA ptr;

	for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
		if (ptr->connectionID == connectionID) {
			*sock = ptr->sock;
			return CMTSuccess;
		}
	}

	return CMTFailure;
}


CMTStatus CMT_SetPrivate(PCMT_CONTROL control, CMUint32 connectionID,
			 CMTPrivate *cmtpriv)
{
  PCMT_DATA ptr;

  for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
    if (ptr->connectionID == connectionID) {
      ptr->priv = cmtpriv;
      return CMTSuccess;
    }
  }
  return CMTFailure;
}

CMTPrivate *CMT_GetPrivate(PCMT_CONTROL control, CMUint32 connectionID)
{
  PCMT_DATA ptr;

  for (ptr = control->cmtDataConnections; ptr != NULL; ptr = ptr->next) {
    if (ptr->connectionID == connectionID) {
      return ptr->priv;
    }
  }
  return NULL;
}

void CMT_FreeItem(CMTItem *p)
{
  CMT_FreeMessage(p);
}

CMTItem CMT_CopyPtrToItem(void* p)
{
    CMTItem value = {0, NULL, 0};

    if (!p) {
        return value;
    }

    value.len = sizeof(p);
    value.data = (unsigned char *) malloc(value.len);
    memcpy(value.data, &p, value.len);

    return value;
}

void * CMT_CopyItemToPtr(CMTItem value)
{
    void * p = NULL;

    if (value.len == sizeof(void*)) {
        memcpy(&p, value.data, value.len);
    }

    return p;
}

CMTStatus CMT_ReferenceControlConnection(PCMT_CONTROL control)
{
    CMT_LOCK(control->mutex);
    control->refCount++;
    CMT_UNLOCK(control->mutex);
    return CMTSuccess;
}

void
CMT_LockConnection(PCMT_CONTROL control)
{
    CMT_LOCK(control->mutex);
}

void
CMT_UnlockConnection(PCMT_CONTROL control)
{
    CMT_UNLOCK(control->mutex);
}