action := vars["action"]

	var serviceSig serviceSignal
	switch madmin.ServiceAction(action) {
	case madmin.ServiceActionRestart:
		serviceSig = serviceRestart
	case madmin.ServiceActionStop:
		serviceSig = serviceStop
	case madmin.ServiceActionFreeze:
		serviceSig = serviceFreeze
	case madmin.ServiceActionUnfreeze:
		serviceSig = serviceUnFreeze
	default:

	} DfsInfo300;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo300 *s;
	} DfsEnumArray300;

	typedef union {
		[case(1)] DfsEnumArray1 *info1;
		[case(3)] DfsEnumArray3 *info3;
		[case(200)] DfsEnumArray200 *info200;
		[case(300)] DfsEnumArray300 *info300;
	} DfsEnumInfo;

	typedef struct {
		uint32_t level,
		[switch_is(level)] DfsEnumInfo e;
	} DfsEnumStruct;

	[op(0x15)]

        case SMB_COM_FIND_CLOSE2:
            c = "SMB_COM_FIND_CLOSE2";
            break;
        case SMB_COM_TREE_DISCONNECT:
            c = "SMB_COM_TREE_DISCONNECT";
            break;
        case SMB_COM_LOGOFF_ANDX:
            c = "SMB_COM_LOGOFF_ANDX";
            break;
        case SMB_COM_ECHO:
            c = "SMB_COM_ECHO";
            break;
        case SMB_COM_MOVE:

		case isSysErrNotDir(err) || isSysErrIsDir(err):
			return nil, dmTime, errFileNotFound
		case isSysErrHandleInvalid(err):
			// This case is special and needs to be handled for windows.
			return nil, dmTime, errFileNotFound
		case isSysErrIO(err):
			return nil, dmTime, errFaultyDisk
		case isSysErrTooManyFiles(err):
			return nil, dmTime, errTooManyOpenFiles
		case isSysErrInvalidArg(err):

					err = msgp.WrapError(err, "Resources", za0001)
					return
				}
			}
		case "Owner":
			z.Owner, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Owner")
				return
			}
		case "Source":
			z.Source, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Source")
				return
			}
		case "Quorum":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {

		},
		// TODO: add more test cases
		// minor <= 21 and checkPilot failing
		// minor <= 20 and checkDestinationRuleTLS failing
		// minor <= 20 and checkExternalNameAlias failing
		// minor <= 20 and checkVirtualServiceHostMatching failing
		// minor <= 21 and checkPassthroughTargetPorts failing
		// minor <= 21 and checkTracing failing
	}

	for _, c := range cases {

        switch ( this.ctlCode ) {
        case Smb2IoctlRequest.FSCTL_DFS_GET_REFERRALS:
            return new DfsReferralResponseBuffer();
        case Smb2IoctlRequest.FSCTL_SRV_REQUEST_RESUME_KEY:
            return new SrvRequestResumeKeyResponse();
        case Smb2IoctlRequest.FSCTL_SRV_COPYCHUNK:
        case Smb2IoctlRequest.FSCTL_SRV_COPYCHUNK_WRITE:

			if _, isZero := rel.Field.ValueOf(ctx, value); !isZero {
				result := reflect.Indirect(rel.Field.ReflectValueOf(ctx, value))
				switch result.Kind() {
				case reflect.Struct:
					reflectResults = reflect.Append(reflectResults, result.Addr())
				case reflect.Slice, reflect.Array:
					for i := 0; i < result.Len(); i++ {
						if elem := result.Index(i); elem.Kind() == reflect.Ptr {

		return
	}
	for {
		select {
		case <-ctx.Done():
			return
		case <-r.wTimer.C:
			r.wlock.Lock()
			r.workers.update()
			r.wlock.Unlock()

		}
	}
}

func (r *ReplicationStats) collectQueueMetrics(ctx context.Context) {
	if r == nil {
		return
	}

	for {
		select {
		case <-ctx.Done():
			return
		case <-r.qTimer.C:
			r.qCache.update()
		}
	}

            switch (c) {
            case '?':
                buf.append("%3f");
                break;
            case '#':
                buf.append("%23");
                break;
            case '@':
                buf.append("%40");
                break;
            case ':':
                buf.append("%3a");
                break;
            case '/':
                buf.append("%2f");