自学教程：C++ xdr_to_generic函数代码示例

static intmgmt_pmap_signout_cbk (struct rpc_req *req, struct iovec *iov, int count,                       void *myframe){        pmap_signout_rsp  rsp   = {0,};        int              ret   = 0;        if (-1 == req->rpc_status) {                rsp.op_ret   = -1;                rsp.op_errno = EINVAL;                goto out;        }        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp);        if (ret < 0) {                gf_log (THIS->name, GF_LOG_ERROR, "XDR decoding failed");                rsp.op_ret   = -1;                rsp.op_errno = EINVAL;                goto out;        }        if (-1 == rsp.op_ret) {                gf_log (THIS->name, GF_LOG_ERROR,                        "failed to register the port with glusterd");                goto out;        }out:        return 0;}

intclient_cbk_cache_invalidation (struct rpc_clnt *rpc, void *mydata, void *data){        int              ret                        = -1;        struct iovec     *iov                       = NULL;        struct gf_upcall upcall_data                = {0,};        uuid_t           gfid;        struct gf_upcall_cache_invalidation ca_data = {0,};        gfs3_cbk_cache_invalidation_req     ca_req  = {0,};        gf_msg_trace (THIS->name, 0, "Upcall callback is called");        if (!rpc || !mydata || !data)                goto out;        iov = (struct iovec *)data;        ret =  xdr_to_generic (*iov, &ca_req,                               (xdrproc_t)xdr_gfs3_cbk_cache_invalidation_req);        if (ret < 0) {                gf_msg (THIS->name, GF_LOG_WARNING, -ret,                        PC_MSG_CACHE_INVALIDATION_FAIL,                        "XDR decode of cache_invalidation failed.");                goto out;        }        upcall_data.data = &ca_data;        gf_proto_cache_invalidation_to_upcall (&ca_req, &upcall_data);        gf_msg_trace (THIS->name, 0, "Upcall gfid = %s, ret = %d",                      ca_req.gfid, ret);        default_notify (THIS, GF_EVENT_UPCALL, &upcall_data);out:        if (ca_req.gfid)                free (ca_req.gfid);        if (ca_req.xdata.xdata_val)                free (ca_req.xdata.xdata_val);        return 0;}

ssize_txdr_to_fsstat3args (struct iovec inmsg, fsstat3args *fa){        return xdr_to_generic (inmsg, (void *)fa,                                   (xdrproc_t)xdr_fsstat3args);}

ssize_txdr_to_readdirp3args (struct iovec inmsg, readdirp3args *rp){        return xdr_to_generic (inmsg, (void *)rp,                                   (xdrproc_t)xdr_readdirp3args);}

ssize_txdr_to_link3args (struct iovec inmsg, link3args *la){        return xdr_to_generic (inmsg, (void *)la, (xdrproc_t)xdr_link3args);}

ssize_txdr_to_rename3args (struct iovec inmsg, rename3args *ra){        return xdr_to_generic (inmsg, (void *)ra,                                   (xdrproc_t)xdr_rename3args);}

static intglusterd_handle_post_validate_fn (rpcsvc_request_t *req){        int32_t                         ret       = -1;        gd1_mgmt_v3_post_val_req         op_req    = {{0},};        xlator_t                       *this      = NULL;        char                           *op_errstr = NULL;        dict_t                         *dict      = NULL;        dict_t                         *rsp_dict  = NULL;        this = THIS;        GF_ASSERT (this);        GF_ASSERT (req);        ret = xdr_to_generic (req->msg[0], &op_req,                              (xdrproc_t)xdr_gd1_mgmt_v3_post_val_req);        if (ret < 0) {                gf_msg (this->name, GF_LOG_ERROR, 0,                        GD_MSG_REQ_DECODE_FAIL,                        "Failed to decode post validation "                        "request received from peer");                req->rpc_err = GARBAGE_ARGS;                goto out;        }        if (glusterd_peerinfo_find_by_uuid (op_req.uuid) == NULL) {                gf_msg (this->name, GF_LOG_WARNING, 0,                        GD_MSG_PEER_NOT_FOUND, "%s doesn't "                        "belong to the cluster. Ignoring request.",                        uuid_utoa (op_req.uuid));                ret = -1;                goto out;        }        dict = dict_new ();        if (!dict)                goto out;        ret = dict_unserialize (op_req.dict.dict_val,                                op_req.dict.dict_len, &dict);        if (ret) {                gf_msg (this->name, GF_LOG_WARNING, 0,                        GD_MSG_DICT_UNSERIALIZE_FAIL,                        "failed to unserialize the dictionary");                goto out;        }        rsp_dict = dict_new ();        if (!rsp_dict) {                gf_msg (this->name, GF_LOG_ERROR, 0,                        GD_MSG_DICT_CREATE_FAIL,                        "Failed to get new dictionary");                return -1;        }        ret = gd_mgmt_v3_post_validate_fn (op_req.op, op_req.op_ret, dict,                                           &op_errstr, rsp_dict);        if (ret) {                gf_msg (this->name, GF_LOG_ERROR, 0,                        GD_MSG_POST_VALIDATION_FAIL,                        "Post Validation failed on operation %s",                        gd_op_list[op_req.op]);        }        ret = glusterd_mgmt_v3_post_validate_send_resp (req, op_req.op,                                                       ret, op_errstr,                                                       rsp_dict);        if (ret) {                gf_msg (this->name, GF_LOG_ERROR, 0,                        GD_MSG_MGMTV3_OP_RESP_FAIL,                        "Failed to send Post Validation "                        "response for operation %s",                        gd_op_list[op_req.op]);                goto out;        }out:        if (op_errstr && (strcmp (op_errstr, "")))                GF_FREE (op_errstr);        free (op_req.dict.dict_val);        if (dict)                dict_unref (dict);        if (rsp_dict)                dict_unref (rsp_dict);        /* Return 0 from handler to avoid double deletion of req obj */        return 0;}

ssize_txdr_to_setaclargs (struct iovec inmsg, setaclargs *args){        return xdr_to_generic (inmsg, (void *) args,                               (xdrproc_t)xdr_setaclargs);}

ssize_txdr_to_commit3args (struct iovec inmsg, commit3args *ca){        return xdr_to_generic (inmsg, (void *)ca,                                   (xdrproc_t)xdr_commit3args);}

ssize_txdr_to_access3args (struct iovec inmsg, access3args *ac){        return xdr_to_generic (inmsg,(void *)ac,                                   (xdrproc_t)xdr_access3args);}

static intglusterd_handle_mgmt_v3_unlock_fn (rpcsvc_request_t *req){        gd1_mgmt_v3_unlock_req  lock_req        = {{0},};        int32_t                 ret             = -1;        glusterd_op_lock_ctx_t *ctx             = NULL;        glusterd_peerinfo_t    *peerinfo        = NULL;        xlator_t               *this            = NULL;        gf_boolean_t            is_synctasked   = _gf_false;        gf_boolean_t            free_ctx        = _gf_false;        this = THIS;        GF_ASSERT (this);        GF_ASSERT (req);        ret = xdr_to_generic (req->msg[0], &lock_req,                              (xdrproc_t)xdr_gd1_mgmt_v3_unlock_req);        if (ret < 0) {                gf_log (this->name, GF_LOG_ERROR, "Failed to decode unlock "                        "request received from peer");                req->rpc_err = GARBAGE_ARGS;                goto out;        }        gf_log (this->name, GF_LOG_DEBUG, "Received volume unlock req "                "from uuid: %s", uuid_utoa (lock_req.uuid));        if (glusterd_friend_find_by_uuid (lock_req.uuid, &peerinfo)) {                gf_log (this->name, GF_LOG_WARNING, "%s doesn't "                        "belong to the cluster. Ignoring request.",                        uuid_utoa (lock_req.uuid));                ret = -1;                goto out;        }        ctx = GF_CALLOC (1, sizeof (*ctx), gf_gld_mt_op_lock_ctx_t);        if (!ctx) {                ret = -1;                goto out;        }        uuid_copy (ctx->uuid, lock_req.uuid);        ctx->req = req;        ctx->dict = dict_new ();        if (!ctx->dict) {                ret = -1;                goto out;        }        ret = dict_unserialize (lock_req.dict.dict_val,                                lock_req.dict.dict_len, &ctx->dict);        if (ret) {                gf_log (this->name, GF_LOG_WARNING,                        "failed to unserialize the dictionary");                goto out;        }        is_synctasked = dict_get_str_boolean (ctx->dict,                                              "is_synctasked", _gf_false);        if (is_synctasked) {                ret = glusterd_syctasked_mgmt_v3_unlock (req, &lock_req, ctx);                /* The above function does not take ownership of ctx.                 * Therefore we need to free the ctx explicitly. */                free_ctx = _gf_true;        }        else {                ret = glusterd_op_state_machine_mgmt_v3_unlock (req, &lock_req,                                                                ctx);        }out:        if (ret || free_ctx) {                if (ctx->dict)                        dict_unref (ctx->dict);                if (ctx)                        GF_FREE (ctx);        }        free (lock_req.dict.dict_val);        gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);        return ret;}

static intglusterd_handle_post_validate_fn (rpcsvc_request_t *req){        int32_t                         ret       = -1;        gd1_mgmt_v3_post_val_req         op_req    = {{0},};        glusterd_peerinfo_t            *peerinfo  = NULL;        xlator_t                       *this      = NULL;        char                           *op_errstr = NULL;        dict_t                         *dict      = NULL;        dict_t                         *rsp_dict  = NULL;        this = THIS;        GF_ASSERT (this);        GF_ASSERT (req);        ret = xdr_to_generic (req->msg[0], &op_req,                              (xdrproc_t)xdr_gd1_mgmt_v3_post_val_req);        if (ret < 0) {                gf_log (this->name, GF_LOG_ERROR,                        "Failed to decode post validation "                        "request received from peer");                req->rpc_err = GARBAGE_ARGS;                goto out;        }        if (glusterd_friend_find_by_uuid (op_req.uuid, &peerinfo)) {                gf_log (this->name, GF_LOG_WARNING, "%s doesn't "                        "belong to the cluster. Ignoring request.",                        uuid_utoa (op_req.uuid));                ret = -1;                goto out;        }        dict = dict_new ();        if (!dict)                goto out;        ret = dict_unserialize (op_req.dict.dict_val,                                op_req.dict.dict_len, &dict);        if (ret) {                gf_log (this->name, GF_LOG_WARNING,                        "failed to unserialize the dictionary");                goto out;        }        rsp_dict = dict_new ();        if (!rsp_dict) {                gf_log (this->name, GF_LOG_ERROR,                        "Failed to get new dictionary");                return -1;        }        ret = gd_mgmt_v3_post_validate_fn (op_req.op, op_req.op_ret, dict,                                           &op_errstr, rsp_dict);        if (ret) {                gf_log (this->name, GF_LOG_ERROR,                        "Post Validation failed on operation %s",                        gd_op_list[op_req.op]);        }        ret = glusterd_mgmt_v3_post_validate_send_resp (req, op_req.op,                                                       ret, op_errstr,                                                       rsp_dict);        if (ret) {                gf_log (this->name, GF_LOG_ERROR,                        "Failed to send Post Validation "                        "response for operation %s",                        gd_op_list[op_req.op]);                goto out;        }out:        if (op_errstr && (strcmp (op_errstr, "")))                GF_FREE (op_errstr);        free (op_req.dict.dict_val);        if (dict)                dict_unref (dict);        if (rsp_dict)                dict_unref (rsp_dict);        gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);        return ret;}

ssize_txdr_to_dump_rsp (struct iovec inmsg, void *args){        return xdr_to_generic (inmsg, (void *)args,                               (xdrproc_t)xdr_gf_dump_rsp);}

intquotad_aggregator_getlimit (rpcsvc_request_t *req){        call_frame_t              *frame = NULL;        gf_cli_req                 cli_req = {{0}, };        gf_cli_rsp                 cli_rsp = {0};        gfs3_lookup_req            args  = {{0,},};        gfs3_lookup_rsp            rsp   = {0,};        quotad_aggregator_state_t *state = NULL;        xlator_t                  *this  = NULL;        dict_t                    *dict  = NULL;        int                        ret   = -1, op_errno = 0;        char                      *gfid_str = NULL;        uuid_t                     gfid = {0};        GF_VALIDATE_OR_GOTO ("quotad-aggregator", req, err);        this = THIS;        ret = xdr_to_generic (req->msg[0], &cli_req, (xdrproc_t)xdr_gf_cli_req);        if (ret < 0)  {                //failed to decode msg;                gf_log ("", GF_LOG_ERROR, "xdr decoding error");                req->rpc_err = GARBAGE_ARGS;                goto err;        }        if (cli_req.dict.dict_len) {                dict = dict_new ();                ret = dict_unserialize (cli_req.dict.dict_val,                                        cli_req.dict.dict_len, &dict);                if (ret < 0) {                        gf_log (this->name, GF_LOG_ERROR, "Failed to "                                "unserialize req-buffer to dictionary");                        goto err;                }        }        ret = dict_get_str (dict, "gfid", &gfid_str);        if (ret) {                goto err;        }        uuid_parse ((const char*)gfid_str, gfid);        frame = quotad_aggregator_get_frame_from_req (req);        if (frame == NULL) {                rsp.op_errno = ENOMEM;                goto err;        }        state = frame->root->state;        state->xdata = dict;        ret = dict_set_int32 (state->xdata, QUOTA_LIMIT_KEY, 42);        if (ret)                goto err;        ret = dict_set_int32 (state->xdata, QUOTA_SIZE_KEY, 42);        if (ret)                goto err;        ret = dict_set_int32 (state->xdata, GET_ANCESTRY_PATH_KEY,42);        if (ret)                goto err;        memcpy (&args.gfid, &gfid, 16);        args.bname           = alloca (req->msg[0].iov_len);        args.xdata.xdata_val = alloca (req->msg[0].iov_len);        ret = qd_nameless_lookup (this, frame, &args, state->xdata,                                  quotad_aggregator_getlimit_cbk);        if (ret) {                rsp.op_errno = ret;                goto err;        }        return ret;err:        cli_rsp.op_ret = -1;        cli_rsp.op_errno = op_errno;        cli_rsp.op_errstr = "";        quotad_aggregator_getlimit_cbk (this, frame, &cli_rsp);        dict_unref (dict);        return ret;}

static intglusterd_handle_mgmt_v3_unlock_fn (rpcsvc_request_t *req){        gd1_mgmt_v3_unlock_req  lock_req        = {{0},};        int32_t                 ret             = -1;        glusterd_op_lock_ctx_t *ctx             = NULL;        xlator_t               *this            = NULL;        gf_boolean_t            is_synctasked   = _gf_false;        gf_boolean_t            free_ctx        = _gf_false;        this = THIS;        GF_ASSERT (this);        GF_ASSERT (req);        ret = xdr_to_generic (req->msg[0], &lock_req,                              (xdrproc_t)xdr_gd1_mgmt_v3_unlock_req);        if (ret < 0) {                gf_msg (this->name, GF_LOG_ERROR, 0,                        GD_MSG_REQ_DECODE_FAIL, "Failed to decode unlock "                        "request received from peer");                req->rpc_err = GARBAGE_ARGS;                goto out;        }        gf_msg_debug (this->name, 0, "Received volume unlock req "                "from uuid: %s", uuid_utoa (lock_req.uuid));        if (glusterd_peerinfo_find_by_uuid (lock_req.uuid) == NULL) {                gf_msg (this->name, GF_LOG_WARNING, 0,                        GD_MSG_PEER_NOT_FOUND, "%s doesn't "                        "belong to the cluster. Ignoring request.",                        uuid_utoa (lock_req.uuid));                ret = -1;                goto out;        }        ctx = GF_CALLOC (1, sizeof (*ctx), gf_gld_mt_op_lock_ctx_t);        if (!ctx) {                ret = -1;                goto out;        }        gf_uuid_copy (ctx->uuid, lock_req.uuid);        ctx->req = req;        ctx->dict = dict_new ();        if (!ctx->dict) {                ret = -1;                goto out;        }        ret = dict_unserialize (lock_req.dict.dict_val,                                lock_req.dict.dict_len, &ctx->dict);        if (ret) {                gf_msg (this->name, GF_LOG_WARNING, 0,                        GD_MSG_DICT_UNSERIALIZE_FAIL,                        "failed to unserialize the dictionary");                goto out;        }        is_synctasked = dict_get_str_boolean (ctx->dict,                                              "is_synctasked", _gf_false);        if (is_synctasked) {                ret = glusterd_syctasked_mgmt_v3_unlock (req, &lock_req, ctx);                if (ret) {                        gf_msg (this->name, GF_LOG_ERROR, 0,                                GD_MSG_MGMTV3_UNLOCK_FAIL,                                "Failed to release mgmt_v3_locks");                        /* Ignore the return code, as it shouldn't be propagated                         * from the handler function so as to avoid double                         * deletion of the req                         */                        ret = 0;                }                /* The above function does not take ownership of ctx.                 * Therefore we need to free the ctx explicitly. */                free_ctx = _gf_true;        }        else {                /* Shouldn't ignore the return code here, and it should                 * be propagated from the handler function as in failure                 * case it doesn't delete the req object                 */                ret = glusterd_op_state_machine_mgmt_v3_unlock (req, &lock_req,                                                                ctx);                if (ret)                        gf_msg (this->name, GF_LOG_ERROR, 0,                                GD_MSG_MGMTV3_UNLOCK_FAIL,                                "Failed to release mgmt_v3_locks");        }out:        if (ctx && (ret || free_ctx)) {                if (ctx->dict)                        dict_unref (ctx->dict);                GF_FREE (ctx);        }//.........这里部分代码省略.........

ssize_txdr_to_fsinfo3args (struct iovec inmsg, fsinfo3args *fi){        return xdr_to_generic (inmsg, (void *)fi,                                   (xdrproc_t)xdr_fsinfo3args);}

ssize_txdr_to_pathconf3args (struct iovec inmsg, pathconf3args *pc){        return xdr_to_generic (inmsg, (void *)pc,                                   (xdrproc_t)xdr_pathconf3args);}

ssize_txdr_to_write3args (struct iovec inmsg, write3args *wa){        return xdr_to_generic (inmsg, (void *)wa,(xdrproc_t)xdr_write3args);}

ssize_txdr_to_nlm4_freeallargs (struct iovec inmsg, nlm4_freeallargs *args){        return xdr_to_generic (inmsg, (void*)args,                               (xdrproc_t)xdr_nlm4_freeallargs);}

ssize_txdr_to_symlink3args (struct iovec inmsg, symlink3args *sa){        return xdr_to_generic (inmsg, (void *)sa,                                   (xdrproc_t)xdr_symlink3args);}

ssize_txdr_to_getattr3args (struct iovec inmsg, getattr3args *ga){        return xdr_to_generic (inmsg, (void *)ga,                                   (xdrproc_t)xdr_getattr3args);}

ssize_txdr_to_mknod3args (struct iovec inmsg, mknod3args *ma){        return xdr_to_generic (inmsg, (void *)ma,                                   (xdrproc_t)xdr_mknod3args);}