int compare_nsm_client(state_nsm_client_t *pclient1,
state_nsm_client_t *pclient2)
{
if(isFullDebug(COMPONENT_STATE) && isDebug(COMPONENT_HASHTABLE))
{
char str1[HASHTABLE_DISPLAY_STRLEN];
char str2[HASHTABLE_DISPLAY_STRLEN];
display_nsm_client(pclient1, str1);
display_nsm_client(pclient2, str2);
LogFullDebug(COMPONENT_STATE,
"{%s} vs {%s}", str1, str2);
}
if(pclient1 == NULL || pclient2 == NULL)
return 1;
if(pclient1 == pclient2)
return 0;
if(!nfs_param.core_param.nsm_use_caller_name)
{
if(cmp_sockaddr(&pclient1->ssc_client_addr, &pclient2->ssc_client_addr, IGNORE_PORT) == 0)
return 1;
return 0;
}
if(pclient1->ssc_nlm_caller_name_len != pclient2->ssc_nlm_caller_name_len)
return 1;
return memcmp(pclient1->ssc_nlm_caller_name,
pclient2->ssc_nlm_caller_name,
pclient1->ssc_nlm_caller_name_len);
}
int nfs4_op_destroy_session(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
DESTROY_SESSION4args * const arg_DESTROY_SESSION4 =
&op->nfs_argop4_u.opdestroy_session;
DESTROY_SESSION4res * const res_DESTROY_SESSION4 =
&resp->nfs_resop4_u.opdestroy_session;
sockaddr_t nw_addr;
sockaddr_t client_addr;
nfs41_session_t *session;
resp->resop = NFS4_OP_DESTROY_SESSION;
res_DESTROY_SESSION4->dsr_status = NFS4_OK;
if (data->minorversion == 0) {
res_DESTROY_SESSION4->dsr_status = NFS4ERR_INVAL;
return res_DESTROY_SESSION4->dsr_status = NFS4ERR_INVAL;
}
if (!nfs41_Session_Get_Pointer(arg_DESTROY_SESSION4->dsa_sessionid,
&session)) {
res_DESTROY_SESSION4->dsr_status = NFS4ERR_BADSESSION;
return res_DESTROY_SESSION4->dsr_status;
}
/* DESTROY_SESSION MUST be invoked on a connection that is associated
* with the session being destroyed
*/
/* Copy the address coming over the wire. */
copy_xprt_addr(&nw_addr, data->req->rq_xprt);
/* Copy the address recorded in the session. */
copy_xprt_addr(&client_addr, session->xprt);
/* Compare these fields. */
if (!cmp_sockaddr(&nw_addr, &client_addr, false)) {
res_DESTROY_SESSION4->dsr_status =
NFS4ERR_CONN_NOT_BOUND_TO_SESSION;
return res_DESTROY_SESSION4->dsr_status;
}
if (!nfs41_Session_Del(arg_DESTROY_SESSION4->dsa_sessionid))
res_DESTROY_SESSION4->dsr_status = NFS4ERR_BADSESSION;
else
res_DESTROY_SESSION4->dsr_status = NFS4_OK;
/* Release ref taken in get_pointer */
dec_session_ref(session);
return res_DESTROY_SESSION4->dsr_status;
} /* nfs41_op_destroy_session */
/**
*
* compare_req: compares the xid, ip, and port stored in the key buffers.
* may also compare the checksum if the relevant option was enabled during
* compile.
*
* compare the xid, ip, and port stored in the key buffers. This function is
* to be used as 'compare_key' field in
* the hashtable storing the nfs duplicated requests.
*
* @param buff1 [IN] first key
* @param buff2 [IN] second key
*
* @return 0 if keys are identifical, 1 if they are different.
*
*/
int compare_req(hash_buffer_t * buff1, hash_buffer_t * buff2)
{
dupreq_key_t *key1 = (dupreq_key_t *)(buff1->pdata);
dupreq_key_t *key2 = (dupreq_key_t *)(buff2->pdata);
if (key1->xid != key2->xid)
return 1;
if (cmp_sockaddr(&key1->addr, &key2->addr, CHECK_PORT) == 0)
return 1;
if (key1->checksum != key2->checksum)
return 1;
return 0;
} /* compare_xid */
bool _IDB_LIST_PEER::find( bool lock, IDB_PEER ** peer, IKE_SADDR * saddr )
{
if( peer != NULL )
*peer = NULL;
if( lock )
iked.lock_idb.lock();
long peer_count = count();
long peer_index = 0;
for( ; peer_index < peer_count; peer_index++ )
{
IDB_PEER * tmp_peer = get( peer_index );
//
// match the peer address
//
if( saddr != NULL )
if( has_sockaddr( &tmp_peer->saddr.saddr ) )
if( !cmp_sockaddr( tmp_peer->saddr.saddr, saddr->saddr, false ) )
continue;
iked.log.txt( LLOG_DEBUG, "DB : peer found\n" );
//
// increase our refrence count
//
if( peer != NULL )
{
tmp_peer->inc( false );
*peer = tmp_peer;
}
if( lock )
iked.lock_idb.unlock();
return true;
}
iked.log.txt( LLOG_DEBUG, "DB : peer not found\n" );
if( lock )
iked.lock_idb.unlock();
return false;
}
/**
* @brief Compare NLM clients
*
* @param[in] client1 A client
* @param[in] client2 Another client
*
* @retval 0 on equality.
* @retval 1 on inequality.
*/
int compare_nlm_client(state_nlm_client_t *client1,
state_nlm_client_t *client2)
{
if (isFullDebug(COMPONENT_STATE) && isDebug(COMPONENT_HASHTABLE)) {
char str1[LOG_BUFF_LEN / 2];
char str2[LOG_BUFF_LEN / 2];
struct display_buffer dspbuf1 = {sizeof(str1), str1, str1};
struct display_buffer dspbuf2 = {sizeof(str2), str2, str2};
display_nlm_client(&dspbuf1, client1);
display_nlm_client(&dspbuf2, client2);
LogFullDebug(COMPONENT_STATE, "{%s} vs {%s}", str1, str2);
}
if (client1 == NULL || client2 == NULL)
return 1;
if (client1 == client2)
return 0;
if (compare_nsm_client(client1->slc_nsm_client, client2->slc_nsm_client)
!= 0)
return 1;
if (cmp_sockaddr(&client1->slc_server_addr,
&client2->slc_server_addr,
true) == 0)
return 1;
if (client1->slc_client_type != client2->slc_client_type)
return 1;
if (client1->slc_nlm_caller_name_len !=
client2->slc_nlm_caller_name_len)
return 1;
return memcmp(client1->slc_nlm_caller_name,
client2->slc_nlm_caller_name,
client1->slc_nlm_caller_name_len);
}
int nfs4_op_setclientid(struct nfs_argop4 *op, compound_data_t *data,
struct nfs_resop4 *resp)
{
SETCLIENTID4args * const arg_SETCLIENTID4 =
&op->nfs_argop4_u.opsetclientid;
SETCLIENTID4res * const res_SETCLIENTID4 =
&resp->nfs_resop4_u.opsetclientid;
clientaddr4 * const res_SETCLIENTID4_INUSE =
&resp->nfs_resop4_u.opsetclientid.SETCLIENTID4res_u.client_using;
char str_verifier[NFS4_VERIFIER_SIZE * 2 + 1];
char str_client[NFS4_OPAQUE_LIMIT * 2 + 1];
char str_client_addr[SOCK_NAME_MAX + 1];
nfs_client_record_t *client_record;
nfs_client_id_t *conf;
nfs_client_id_t *unconf;
clientid4 clientid;
verifier4 verifier;
sockaddr_t client_addr;
int rc;
resp->resop = NFS4_OP_SETCLIENTID;
if (data->minorversion > 0) {
res_SETCLIENTID4->status = NFS4ERR_NOTSUPP;
return res_SETCLIENTID4->status;
}
copy_xprt_addr(&client_addr, data->req->rq_xprt);
if (isDebug(COMPONENT_CLIENTID)) {
sprint_sockip(&client_addr, str_client_addr,
sizeof(str_client_addr));
DisplayOpaqueValue(arg_SETCLIENTID4->client.id.id_val,
arg_SETCLIENTID4->client.id.id_len,
str_client);
sprint_mem(str_verifier, arg_SETCLIENTID4->client.verifier,
NFS4_VERIFIER_SIZE);
}
LogDebug(COMPONENT_CLIENTID,
"SETCLIENTID Client addr=%s id=%s verf=%s callback={program=%u r_addr=%s r_netid=%s} ident=%u",
str_client_addr, str_client, str_verifier,
arg_SETCLIENTID4->callback.cb_program,
arg_SETCLIENTID4->callback.cb_location.r_addr,
arg_SETCLIENTID4->callback.cb_location.r_netid,
arg_SETCLIENTID4->callback_ident);
/* Do we already have one or more records for client id (x)? */
client_record = get_client_record(arg_SETCLIENTID4->client.id.id_val,
arg_SETCLIENTID4->client.id.id_len,
0,
0);
if (client_record == NULL) {
/* Some major failure */
LogCrit(COMPONENT_CLIENTID, "SETCLIENTID failed");
res_SETCLIENTID4->status = NFS4ERR_SERVERFAULT;
return res_SETCLIENTID4->status;
}
/* The following checks are based on RFC3530bis draft 16
*
* This attempts to implement the logic described in
* 15.35.5. IMPLEMENTATION Consider the major bullets as CASE
* 1, CASE 2, CASE 3, CASE 4, and CASE 5.
*/
pthread_mutex_lock(&client_record->cr_mutex);
if (isFullDebug(COMPONENT_CLIENTID)) {
char str[HASHTABLE_DISPLAY_STRLEN];
display_client_record(client_record, str);
LogFullDebug(COMPONENT_CLIENTID,
"Client Record %s cr_confirmed_rec=%p "
"cr_unconfirmed_rec=%p", str,
client_record->cr_confirmed_rec,
client_record->cr_unconfirmed_rec);
}
conf = client_record->cr_confirmed_rec;
if (conf != NULL) {
/* Need a reference to the confirmed record for below */
inc_client_id_ref(conf);
if (!nfs_compare_clientcred(&conf->cid_credential,
&data->credential)
|| !cmp_sockaddr(&conf->cid_client_addr,
&client_addr,
true)) {
/* CASE 1:
*
* Confirmed record exists and not the same principal
*/
if (isDebug(COMPONENT_CLIENTID)) {
char confirmed_addr[SOCK_NAME_MAX + 1];
sprint_sockip(&conf->cid_client_addr,
confirmed_addr,
sizeof(confirmed_addr));
LogDebug(COMPONENT_CLIENTID,
"Confirmed ClientId %" PRIx64
"->'%s': Principals do not match... confirmed addr=%s Return NFS4ERR_CLID_INUSE",
conf->cid_clientid, str_client,
confirmed_addr);
}
res_SETCLIENTID4->status = NFS4ERR_CLID_INUSE;
res_SETCLIENTID4_INUSE->r_netid =
(char *)netid_nc_table[conf->cid_cb.v40.cb_addr.nc]
.netid;
res_SETCLIENTID4_INUSE->r_addr =
gsh_strdup(conf->cid_cb.v40.cb_client_r_addr);
/* Release our reference to the confirmed clientid. */
dec_client_id_ref(conf);
goto out;
}
/* Check if confirmed record is for (v, x, c, l, s) */
if (memcmp
(arg_SETCLIENTID4->client.verifier,
conf->cid_incoming_verifier, NFS4_VERIFIER_SIZE) == 0) {
/* CASE 2:
*
* A confirmed record exists for this long
* form client id and verifier.
*
* Consider this to be a possible update of
* the call-back information.
*
* Remove any pre-existing unconfirmed record
* for (v, x, c).
*
* Return the same short form client id (c),
* but a new setclientid_confirm verifier (t).
*/
LogFullDebug(COMPONENT_CLIENTID,
"Update ClientId %" PRIx64 "->%s",
conf->cid_clientid, str_client);
clientid = conf->cid_clientid;
new_clientid_verifier(verifier);
} else {
/* Must be CASE 3 or CASE 4
*
* Confirmed record is for (u, x, c, l, s).
*
* These are actually the same, doesn't really
* matter if an unconfirmed record exists or
* not. Any existing unconfirmed record will
* be removed and a new unconfirmed record
* added.
*
* Return a new short form clientid (d) and a
* new setclientid_confirm verifier (t). (Note
* the spec calls the values e and r for CASE
* 4).
*/
LogFullDebug(COMPONENT_CLIENTID,
"Replace ClientId %" PRIx64 "->%s",
conf->cid_clientid, str_client);
clientid = new_clientid();
new_clientid_verifier(verifier);
}
/* Release our reference to the confirmed clientid. */
dec_client_id_ref(conf);
} else {
/* CASE 5:
*
*
* Remove any existing unconfirmed record.
*
* Return a new short form clientid (d) and a new
* setclientid_confirm verifier (t).
*/
LogFullDebug(COMPONENT_CLIENTID, "New client");
clientid = new_clientid();
new_clientid_verifier(verifier);
}
/* At this point, no matter what the case was above, we should
* remove any pre-existing unconfirmed record.
*/
unconf = client_record->cr_unconfirmed_rec;
if (unconf != NULL) {
/* Delete the unconfirmed clientid record. Because we
* have the cr_mutex, we have won any race to deal
* with this clientid record (whether we raced with a
* SETCLIENTID_CONFIRM or the reaper thread (if either
* of those operations had won the race,
* cr_punconfirmed_id would have been NULL).
*/
if (isDebug(COMPONENT_CLIENTID)) {
char str[HASHTABLE_DISPLAY_STRLEN];
display_client_id_rec(unconf, str);
LogDebug(COMPONENT_CLIENTID, "Replacing %s", str);
}
/* unhash the clientid record */
remove_unconfirmed_client_id(unconf);
unconf = NULL;
}
/* Now we can proceed to build the new unconfirmed record. We
* have determined the clientid and setclientid_confirm values
* above.
*/
unconf = create_client_id(clientid,
client_record,
&client_addr,
&data->credential,
0);
if (unconf == NULL) {
/* Error already logged, return */
res_SETCLIENTID4->status = NFS4ERR_RESOURCE;
goto out;
}
if (strmaxcpy(unconf->cid_cb.v40.cb_client_r_addr,
arg_SETCLIENTID4->callback.cb_location.r_addr,
sizeof(unconf->cid_cb.v40.cb_client_r_addr)) == -1) {
LogCrit(COMPONENT_CLIENTID, "Callback r_addr %s too long",
arg_SETCLIENTID4->callback.cb_location.r_addr);
res_SETCLIENTID4->status = NFS4ERR_INVAL;
goto out;
}
nfs_set_client_location(unconf,
&arg_SETCLIENTID4->callback.cb_location);
memcpy(unconf->cid_incoming_verifier,
arg_SETCLIENTID4->client.verifier,
NFS4_VERIFIER_SIZE);
memcpy(unconf->cid_verifier, verifier, sizeof(NFS4_write_verifier));
unconf->cid_cb.v40.cb_program = arg_SETCLIENTID4->callback.cb_program;
unconf->cid_cb.v40.cb_callback_ident = arg_SETCLIENTID4->callback_ident;
rc = nfs_client_id_insert(unconf);
if (rc != CLIENT_ID_SUCCESS) {
/* Record is already freed, return. */
res_SETCLIENTID4->status = clientid_error_to_nfsstat(rc);
goto out;
}
if (isDebug(COMPONENT_CLIENTID)) {
char str[HASHTABLE_DISPLAY_STRLEN];
sprint_mem(str_verifier, verifier, NFS4_VERIFIER_SIZE);
display_client_id_rec(unconf, str);
LogDebug(COMPONENT_CLIENTID, "SETCLIENTID reply Verifier=%s %s",
str_verifier, str);
}
res_SETCLIENTID4->status = NFS4_OK;
res_SETCLIENTID4->SETCLIENTID4res_u.resok4.clientid = clientid;
memcpy(res_SETCLIENTID4->SETCLIENTID4res_u.resok4.setclientid_confirm,
&verifier, NFS4_VERIFIER_SIZE);
out:
pthread_mutex_unlock(&client_record->cr_mutex);
/* Release our reference to the client record */
dec_client_record_ref(client_record);
return res_SETCLIENTID4->status;
}
int nfs41_op_exchange_id(struct nfs_argop4 *op,
compound_data_t * data, struct nfs_resop4 *resp)
{
char str_verifier[NFS4_VERIFIER_SIZE * 2 + 1];
char str_client[NFS4_OPAQUE_LIMIT * 2 + 1];
nfs_client_record_t * pclient_record;
nfs_client_id_t * pconf;
nfs_client_id_t * punconf;
int rc;
int len;
char * temp;
bool_t update;
const char * update_str;
log_components_t component = COMPONENT_CLIENTID;
#if 0 /** @todo: plante le client sous windows. Ai-je réellement besoin de cela ???? */
/* Check flags value (test EID4) */
if(arg_EXCHANGE_ID4.eia_flags & all_eia_flags != arg_EXCHANGE_ID4.eia_flags)
{
res_EXCHANGE_ID4.eir_status = NFS4ERR_INVAL;
return res_EXCHANGE_ID4.eir_status;
}
#endif
if(isDebug(COMPONENT_SESSIONS))
component = COMPONENT_SESSIONS;
#define arg_EXCHANGE_ID4 op->nfs_argop4_u.opexchange_id
#define res_EXCHANGE_ID4 resp->nfs_resop4_u.opexchange_id
#define res_EXCHANGE_ID4_ok resp->nfs_resop4_u.opexchange_id.EXCHANGE_ID4res_u.eir_resok4
resp->resop = NFS4_OP_EXCHANGE_ID;
update = (arg_EXCHANGE_ID4.eia_flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) != 0;
if(isDebug(component))
{
DisplayOpaqueValue(arg_EXCHANGE_ID4.eia_clientowner.co_ownerid.co_ownerid_val,
arg_EXCHANGE_ID4.eia_clientowner.co_ownerid.co_ownerid_len,
str_client);
sprint_mem(str_verifier,
arg_EXCHANGE_ID4.eia_clientowner.co_verifier,
NFS4_VERIFIER_SIZE);
update_str = update ? "UPDATE" : "NO UPDATE";
}
LogDebug(component,
"EXCHANGE_ID Client addr=%s id=%s verf=%s %s --------------------",
data->pworker->hostaddr_str,
str_client, str_verifier, update_str);
/* Do we already have one or more records for client id (x)? */
pclient_record = get_client_record(arg_EXCHANGE_ID4.eia_clientowner.co_ownerid.co_ownerid_val,
arg_EXCHANGE_ID4.eia_clientowner.co_ownerid.co_ownerid_len);
if(pclient_record == NULL)
{
/* Some major failure */
LogCrit(component,
"EXCHANGE_ID failed");
res_EXCHANGE_ID4.eir_status = NFS4ERR_SERVERFAULT;
return res_EXCHANGE_ID4.eir_status;
}
/*
* The following checks are based on RFC5661
*
* This attempts to implement the logic described in 18.35.4. IMPLEMENTATION
*/
P(pclient_record->cr_mutex);
if(isFullDebug(COMPONENT_CLIENTID))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_client_record(pclient_record, str);
LogFullDebug(COMPONENT_CLIENTID,
"Client Record %s cr_pconfirmed_id=%p cr_punconfirmed_id=%p",
str,
pclient_record->cr_pconfirmed_id,
pclient_record->cr_punconfirmed_id);
}
pconf = pclient_record->cr_pconfirmed_id;
if(pconf != NULL)
{
/* Need a reference to the confirmed record for below */
inc_client_id_ref(pconf);
}
if(pconf != NULL && !update)
{
/* EXCHGID4_FLAG_UPD_CONFIRMED_REC_A not set */
/** @todo FSF: old code ifdefed out nfs_compare_clientcred with _NFSV4_COMPARE_CRED_IN_EXCHANGE_ID */
if(!nfs_compare_clientcred(&pconf->cid_credential, &data->credential) ||
!cmp_sockaddr(&pconf->cid_client_addr,
&data->pworker->hostaddr,
IGNORE_PORT))
{
/** @todo FSF: should also check if there is no state */
P(pconf->cid_mutex);
if(valid_lease(pconf))
{
V(pconf->cid_mutex);
/* CASE 3, client collisions, old clientid is expired */
if(isDebug(COMPONENT_CLIENTID))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_client_id_rec(pconf, str);
LogDebug(COMPONENT_CLIENTID,
"Expiring %s",
str);
}
/* Expire clientid and release our reference. */
nfs_client_id_expire(pconf);
dec_client_id_ref(pconf);
pconf = NULL;
}
else
{
V(pconf->cid_mutex);
/* CASE 3, client collisions, old clientid is not expired */
if(isDebug(component))
{
char confirmed_addr[SOCK_NAME_MAX];
sprint_sockip(&pconf->cid_client_addr, confirmed_addr, sizeof(confirmed_addr));
LogDebug(component,
"Confirmed ClientId %"PRIx64"->'%s': Principals do not match... confirmed addr=%s Return NFS4ERR_CLID_INUSE",
pconf->cid_clientid, str_client, confirmed_addr);
}
res_EXCHANGE_ID4.eir_status = NFS4ERR_CLID_INUSE;
/* Release our reference to the confirmed clientid. */
dec_client_id_ref(pconf);
goto out;
}
}
else if(memcmp(arg_EXCHANGE_ID4.eia_clientowner.co_verifier,
pconf->cid_incoming_verifier,
NFS4_VERIFIER_SIZE) == 0)
{
/* CASE 2, Non-Update on Existing Client ID */
/* Return what was last returned without changing any refcounts */
LogDebug(COMPONENT_CLIENTID,
"Non-update of confirmed ClientId %"PRIx64"->%s",
pconf->cid_clientid, str_client);
punconf = pconf;
goto return_ok;
}
else
{
/* CASE 5, client restart */
/** @todo FSF: expire old clientid? */
LogDebug(component,
"Restarted ClientId %"PRIx64"->%s",
pconf->cid_clientid, str_client);
}
}
else if(pconf != NULL)
{
/* EXCHGID4_FLAG_UPD_CONFIRMED_REC_A set */
if(memcmp(arg_EXCHANGE_ID4.eia_clientowner.co_verifier,
pconf->cid_incoming_verifier,
NFS4_VERIFIER_SIZE) == 0)
{
/** @todo FSF: old code ifdefed out nfs_compare_clientcred with _NFSV4_COMPARE_CRED_IN_EXCHANGE_ID */
if(!nfs_compare_clientcred(&pconf->cid_credential, &data->credential) ||
!cmp_sockaddr(&pconf->cid_client_addr,
&data->pworker->hostaddr,
IGNORE_PORT))
{
/* CASE 9, Update but wrong principal */
if(isDebug(component))
{
char confirmed_addr[SOCK_NAME_MAX];
sprint_sockip(&pconf->cid_client_addr, confirmed_addr, sizeof(confirmed_addr));
LogDebug(component,
"Confirmed ClientId %"PRIx64"->'%s': Principals do not match... confirmed addr=%s Return NFS4ERR_PERM",
pconf->cid_clientid, str_client, confirmed_addr);
}
res_EXCHANGE_ID4.eir_status = NFS4ERR_PERM;
}
else
{
/* CASE 6, Update */
/** @todo: this is not implemented, the things it updates aren't even tracked */
LogMajor(component,
"EXCHANGE_ID Update not supported");
res_EXCHANGE_ID4.eir_status = NFS4ERR_NOTSUPP;
}
}
else
{
/* CASE 8, Update but wrong verifier */
if(isDebug(component))
{
char str_old_verifier[NFS4_VERIFIER_SIZE * 2 + 1];
sprint_mem(str_old_verifier,
pconf->cid_incoming_verifier,
NFS4_VERIFIER_SIZE);
LogDebug(component,
"Confirmed clientid %"PRIx64"->'%s': Verifiers do not match... confirmed verifier=%s",
pconf->cid_clientid, str_client, str_old_verifier);
}
res_EXCHANGE_ID4.eir_status = NFS4ERR_NOT_SAME;
}
/* Release our reference to the confirmed clientid. */
dec_client_id_ref(pconf);
goto out;
}
else if(pconf == NULL && update)
{
LogDebug(component,
"No confirmed clientid to update for %s",
str_client);
res_EXCHANGE_ID4.eir_status = NFS4ERR_NOENT;
goto out;
}
/* At this point, no matter what the case was above, we should remove any
* pre-existing unconfirmed record.
*/
punconf = pclient_record->cr_punconfirmed_id;
if(punconf != NULL)
{
/* CASE 4, replacement of unconfirmed record */
/* Delete the unconfirmed clientid record */
if(isDebug(COMPONENT_CLIENTID))
{
char str[HASHTABLE_DISPLAY_STRLEN];
display_client_id_rec(punconf, str);
LogDebug(COMPONENT_CLIENTID,
"Replacing %s",
str);
}
/* unhash the clientid record */
remove_unconfirmed_client_id(punconf);
}
/* Now we can proceed to build the new unconfirmed record. We have determined
* the clientid and setclientid_confirm values above.
*/
punconf = create_client_id(0,
pclient_record,
&data->pworker->hostaddr,
&data->credential);
if(punconf == NULL)
{
/* Error already logged, return */
res_EXCHANGE_ID4.eir_status = NFS4ERR_RESOURCE;
goto out;
}
memcpy(punconf->cid_incoming_verifier,
arg_EXCHANGE_ID4.eia_clientowner.co_verifier,
NFS4_VERIFIER_SIZE);
if(gethostname(punconf->cid_server_owner,
sizeof(punconf->cid_server_owner)) == -1)
{
/* Free the clientid record and return */
free_client_id(punconf);
res_EXCHANGE_ID4.eir_status = NFS4ERR_SERVERFAULT;
goto out;
}
snprintf(punconf->cid_server_scope,
sizeof(punconf->cid_server_scope),
"%s_NFS-Ganesha",
punconf->cid_server_owner);
rc = nfs_client_id_insert(punconf);
if(rc != CLIENT_ID_SUCCESS)
{
/* Record is already freed, return. */
res_EXCHANGE_ID4.eir_status = clientid_error_to_nfsstat(rc);
goto out;
}
return_ok:
/* Build the reply */
res_EXCHANGE_ID4_ok.eir_clientid = punconf->cid_clientid;
res_EXCHANGE_ID4_ok.eir_sequenceid = punconf->cid_create_session_sequence;
#if defined(_USE_FSALMDS) && defined(_USE_FSALDS)
res_EXCHANGE_ID4_ok.eir_flags = EXCHGID4_FLAG_USE_PNFS_MDS |
EXCHGID4_FLAG_USE_PNFS_DS |
EXCHGID4_FLAG_SUPP_MOVED_REFER;
#elif defined(_USE_FSALMDS)
res_EXCHANGE_ID4_ok.eir_flags = EXCHGID4_FLAG_USE_PNFS_MDS |
EXCHGID4_FLAG_SUPP_MOVED_REFER;
#elif defined(_USE_FSALDS)
res_EXCHANGE_ID4_ok.eir_flags = EXCHGID4_FLAG_USE_PNFS_DS |
EXCHGID4_FLAG_SUPP_MOVED_REFER;
#elif defined(_USE_DS)
res_EXCHANGE_ID4_ok.eir_flags = EXCHGID4_FLAG_USE_PNFS_MDS |
EXCHGID4_FLAG_USE_PNFS_DS |
EXCHGID4_FLAG_SUPP_MOVED_REFER;
#else
res_EXCHANGE_ID4_ok.eir_flags = EXCHGID4_FLAG_USE_NON_PNFS |
EXCHGID4_FLAG_SUPP_MOVED_REFER;
#endif
res_EXCHANGE_ID4_ok.eir_state_protect.spr_how = SP4_NONE;
len = strlen(punconf->cid_server_owner);
temp = gsh_malloc(len);
if(temp == NULL)
{
LogDebug(component,
"Could not allocate memory for so_major_id in response");
/** @todo FSF: not the best way to handle this but keeps from crashing */
len = 0;
}
else
memcpy(temp, punconf->cid_server_owner, len);
res_EXCHANGE_ID4_ok.eir_server_owner.so_major_id.so_major_id_len = len;
res_EXCHANGE_ID4_ok.eir_server_owner.so_major_id.so_major_id_val = temp;
res_EXCHANGE_ID4_ok.eir_server_owner.so_minor_id = 0;
len = strlen(punconf->cid_server_scope);
temp = gsh_malloc(len);
if(temp == NULL)
{
LogDebug(component,
"Could not allocate memory for eir_server_scope in response");
/** @todo FSF: not the best way to handle this but keeps from crashing */
len = 0;
}
else
memcpy(temp, punconf->cid_server_scope, len);
res_EXCHANGE_ID4_ok.eir_server_scope.eir_server_scope_len = len;
res_EXCHANGE_ID4_ok.eir_server_scope.eir_server_scope_val = temp;
res_EXCHANGE_ID4_ok.eir_server_impl_id.eir_server_impl_id_len = 0;
res_EXCHANGE_ID4_ok.eir_server_impl_id.eir_server_impl_id_val = NULL;
if(isDebug(COMPONENT_CLIENTID))
{
char str[HASHTABLE_DISPLAY_STRLEN];
sprint_mem(str_verifier,
arg_EXCHANGE_ID4.eia_clientowner.co_verifier,
NFS4_VERIFIER_SIZE);
display_client_id_rec(punconf, str);
LogDebug(COMPONENT_CLIENTID,
"EXCHANGE_ID reply Verifier=%s %s",
str_verifier, str);
}
res_EXCHANGE_ID4.eir_status = NFS4_OK;
out:
V(pclient_record->cr_mutex);
/* Release our reference to the client record */
dec_client_record_ref(pclient_record);
return res_EXCHANGE_ID4.eir_status;
} /* nfs41_op_exchange_id */
/**
*
* compare_ip_stats: compares the ip address stored in the key buffers.
*
* compare the ip address stored in the key buffers. This function is to be used as 'compare_key' field in
* the hashtable storing the nfs duplicated requests.
*
* @param buff1 [IN] first key
* @param buff2 [IN] second key
*
* @return 0 if keys are identifical, 1 if they are different.
*
*/
int compare_ip_stats(hash_buffer_t * buff1, hash_buffer_t * buff2)
{
return (cmp_sockaddr((sockaddr_t *)(buff1->pdata), (sockaddr_t *)(buff2->pdata), IGNORE_PORT) != 0) ? 0 : 1;
}
void ipv6cmp() {
EQUALS(cmp_sockaddr(&ipv6a, &ipv6b, IGNORE_PORT), 1, "ipv6a comapred to ipv6b no port");
EQUALS(cmp_sockaddr(&ipv6a, &ipv6b, CHECK_PORT), 0, "ipv6a comapred to ipv6b with port");
EQUALS(cmp_sockaddr(&ipv6a, &ipv6c, IGNORE_PORT), 0, "ipv6a comapred to ipv6c no port");
EQUALS(cmp_sockaddr(&ipv6a, &ipv6c, CHECK_PORT), 0, "ipv6a comapred to ipv6c with port");
}
void ipv4cmp() {
EQUALS(cmp_sockaddr(&ipv4a, &ipv4b, IGNORE_PORT), 1, "ipv4a comapred to ipv4b no port");
EQUALS(cmp_sockaddr(&ipv4a, &ipv4b, CHECK_PORT), 0, "ipv4a comapred to ipv4b with port");
EQUALS(cmp_sockaddr(&ipv4a, &ipv4c, IGNORE_PORT), 0, "ipv4a comapred to ipv4c no port");
EQUALS(cmp_sockaddr(&ipv4a, &ipv4c, CHECK_PORT), 0, "ipv4a comapred to ipv4c with port");
}
/**
*
* compare_ip_name: compares the ip address stored in the key buffers.
*
* compare the ip address stored in the key buffers. This function is to be used
* as 'compare_key' field in the hashtable storing the nfs duplicated requests.
*
* @param buff1 [IN] first key
* @param buff2 [IN] second key
*
* @return 0 if keys are identifical, 1 if they are different.
*
*/
int compare_ip_name(struct gsh_buffdesc *buff1, struct gsh_buffdesc *buff2)
{
return (cmp_sockaddr(buff1->addr, buff2->addr, true) !=
0) ? 0 : 1;
}
