1package sessionwire
2
3// Directional envelope adaptation.
4//
5// encodeProtoClient/encodeProtoServer wrap one semantic message in its
6// directional envelope; decodeProtoClient/decodeProtoServer unwrap and
7// validate. Wrong-direction payloads fail with ErrWrongDirection before any
8// mutation. The typed connection adapters call these on every send and
9// receive; serialized envelope ceilings are enforced by proto_limits.go.
10
11import (
12 "github.com/bnema/vev/internal/protocol"
13 "github.com/bnema/vev/internal/protocol/wire"
14)
15
16func encodeProtoClient(message protocol.ClientMessage) (*wire.ClientEnvelope, error) {
17 switch m := message.(type) {
18 case protocol.SuspendAttachment:
19 converted, err := suspendAttachmentToWire(m)
20 if err != nil {
21 return nil, err
22 }
23 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_SuspendAttachment{SuspendAttachment: converted}}, nil
24 case *protocol.SuspendAttachment:
25 if m == nil {
26 return nil, ErrInvalidMessage
27 }
28 return encodeProtoClient(*m)
29 case protocol.ActivateAttachment:
30 converted, err := activateAttachmentToWire(m)
31 if err != nil {
32 return nil, err
33 }
34 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_ActivateAttachment{ActivateAttachment: converted}}, nil
35 case *protocol.ActivateAttachment:
36 if m == nil {
37 return nil, ErrInvalidMessage
38 }
39 return encodeProtoClient(*m)
40 case protocol.Hello:
41 converted, err := helloToWire(m)
42 if err != nil {
43 return nil, err
44 }
45 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Hello{Hello: converted}}, nil
46 case *protocol.Hello:
47 if m == nil {
48 return nil, ErrInvalidMessage
49 }
50 return encodeProtoClient(*m)
51 case protocol.Input:
52 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Input{Input: inputToWire(m)}}, nil
53 case *protocol.Input:
54 if m == nil {
55 return nil, ErrInvalidMessage
56 }
57 return encodeProtoClient(*m)
58 case protocol.Resize:
59 converted, err := resizeToWire(m)
60 if err != nil {
61 return nil, err
62 }
63 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Resize{Resize: converted}}, nil
64 case *protocol.Resize:
65 if m == nil {
66 return nil, ErrInvalidMessage
67 }
68 return encodeProtoClient(*m)
69 case protocol.Detach:
70 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Detach{Detach: &wire.Detach{Closed: m.Closed}}}, nil
71 case *protocol.Detach:
72 if m == nil {
73 return nil, ErrInvalidMessage
74 }
75 return encodeProtoClient(*m)
76 case protocol.Ping:
77 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Ping{Ping: &wire.Ping{}}}, nil
78 case *protocol.Ping:
79 if m == nil {
80 return nil, ErrInvalidMessage
81 }
82 return encodeProtoClient(*m)
83 case protocol.List:
84 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_List{List: &wire.List{}}}, nil
85 case *protocol.List:
86 if m == nil {
87 return nil, ErrInvalidMessage
88 }
89 return encodeProtoClient(*m)
90 case protocol.Kill:
91 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Kill{Kill: killToWire(m)}}, nil
92 case *protocol.Kill:
93 if m == nil {
94 return nil, ErrInvalidMessage
95 }
96 return encodeProtoClient(*m)
97 case protocol.Theme:
98 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Theme{Theme: themeToWire(m)}}, nil
99 case *protocol.Theme:
100 if m == nil {
101 return nil, ErrInvalidMessage
102 }
103 return encodeProtoClient(*m)
104 case protocol.Ack:
105 converted, err := ackToWire(m)
106 if err != nil {
107 return nil, err
108 }
109 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_Ack{Ack: converted}}, nil
110 case *protocol.Ack:
111 if m == nil {
112 return nil, ErrInvalidMessage
113 }
114 return encodeProtoClient(*m)
115 case protocol.ImagePush:
116 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_ImagePush{ImagePush: imagePushToWire(m)}}, nil
117 case *protocol.ImagePush:
118 if m == nil {
119 return nil, ErrInvalidMessage
120 }
121 return encodeProtoClient(*m)
122 case protocol.ClientNotice:
123 converted, err := clientNoticeToWire(m)
124 if err != nil {
125 return nil, err
126 }
127 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_ClientNotice{ClientNotice: converted}}, nil
128 case *protocol.ClientNotice:
129 if m == nil {
130 return nil, ErrInvalidMessage
131 }
132 return encodeProtoClient(*m)
133 case protocol.CommandRequest:
134 converted, err := commandRequestToWire(m)
135 if err != nil {
136 return nil, err
137 }
138 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_CommandRequest{CommandRequest: converted}}, nil
139 case *protocol.CommandRequest:
140 if m == nil {
141 return nil, ErrInvalidMessage
142 }
143 return encodeProtoClient(*m)
144 case protocol.OutputResetRequest:
145 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_OutputResetRequest{OutputResetRequest: &wire.OutputResetRequest{}}}, nil
146 case *protocol.OutputResetRequest:
147 if m == nil {
148 return nil, ErrInvalidMessage
149 }
150 return encodeProtoClient(*m)
151 case protocol.SelectTab:
152 converted, err := selectTabToWire(m)
153 if err != nil {
154 return nil, err
155 }
156 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_SelectTab{SelectTab: converted}}, nil
157 case *protocol.SelectTab:
158 if m == nil {
159 return nil, ErrInvalidMessage
160 }
161 return encodeProtoClient(*m)
162 case protocol.TerminalFocus:
163 converted, err := terminalFocusToWire(m)
164 if err != nil {
165 return nil, err
166 }
167 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_TerminalFocus{TerminalFocus: converted}}, nil
168 case *protocol.TerminalFocus:
169 if m == nil {
170 return nil, ErrInvalidMessage
171 }
172 return encodeProtoClient(*m)
173 case protocol.ModifierState:
174 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_ModifierState{ModifierState: &wire.ModifierState{Ctrl: m.Ctrl}}}, nil
175 case *protocol.ModifierState:
176 if m == nil {
177 return nil, ErrInvalidMessage
178 }
179 return encodeProtoClient(*m)
180 case protocol.UIFence:
181 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_UiFence{UiFence: uiFenceToWire(m)}}, nil
182 case *protocol.UIFence:
183 if m == nil {
184 return nil, ErrInvalidMessage
185 }
186 return encodeProtoClient(*m)
187 case protocol.RemotePreviewWatch:
188 converted, err := remotePreviewWatchToWire(m)
189 if err != nil {
190 return nil, err
191 }
192 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RemotePreviewWatch{RemotePreviewWatch: converted}}, nil
193 case *protocol.RemotePreviewWatch:
194 if m == nil {
195 return nil, ErrInvalidMessage
196 }
197 return encodeProtoClient(*m)
198 case protocol.RouteAttentionSubscription:
199 converted, err := attentionSubscriptionToWire(m)
200 if err != nil {
201 return nil, err
202 }
203 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RouteAttentionSubscription{RouteAttentionSubscription: converted}}, nil
204 case *protocol.RouteAttentionSubscription:
205 if m == nil {
206 return nil, ErrInvalidMessage
207 }
208 return encodeProtoClient(*m)
209 case protocol.SamePeerSwitchRequest:
210 converted, err := samePeerSwitchRequestToWire(m)
211 if err != nil {
212 return nil, err
213 }
214 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_SamePeerSwitchRequest{SamePeerSwitchRequest: converted}}, nil
215 case *protocol.SamePeerSwitchRequest:
216 if m == nil {
217 return nil, ErrInvalidMessage
218 }
219 return encodeProtoClient(*m)
220 case protocol.NavigationInventoryRequest:
221 converted, err := inventoryRequestToWire(m)
222 if err != nil {
223 return nil, err
224 }
225 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_NavigationInventoryRequest{NavigationInventoryRequest: converted}}, nil
226 case *protocol.NavigationInventoryRequest:
227 if m == nil {
228 return nil, ErrInvalidMessage
229 }
230 return encodeProtoClient(*m)
231 case protocol.NavigationInventoryPublication:
232 converted, err := inventoryPublicationToWire(m)
233 if err != nil {
234 return nil, err
235 }
236 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_NavigationInventoryPublication{NavigationInventoryPublication: converted}}, nil
237 case *protocol.NavigationInventoryPublication:
238 if m == nil {
239 return nil, ErrInvalidMessage
240 }
241 return encodeProtoClient(*m)
242 case protocol.NavigationInventoryFailure:
243 converted, err := inventoryFailureToWire(m)
244 if err != nil {
245 return nil, err
246 }
247 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_NavigationInventoryFailure{NavigationInventoryFailure: converted}}, nil
248 case *protocol.NavigationInventoryFailure:
249 if m == nil {
250 return nil, ErrInvalidMessage
251 }
252 return encodeProtoClient(*m)
253 case protocol.PickerClose:
254 converted, err := pickerCloseToWire(m)
255 if err != nil {
256 return nil, err
257 }
258 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_PickerClose{PickerClose: converted}}, nil
259 case *protocol.PickerClose:
260 if m == nil {
261 return nil, ErrInvalidMessage
262 }
263 return encodeProtoClient(*m)
264 case protocol.PickerSelection:
265 converted, err := pickerSelectionToWire(m)
266 if err != nil {
267 return nil, err
268 }
269 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_PickerSelection{PickerSelection: converted}}, nil
270 case *protocol.PickerSelection:
271 if m == nil {
272 return nil, ErrInvalidMessage
273 }
274 return encodeProtoClient(*m)
275 case protocol.RecentRouteSnapshot:
276 converted, err := recentRouteSnapshotToWire(m)
277 if err != nil {
278 return nil, err
279 }
280 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RecentRouteSnapshot{RecentRouteSnapshot: converted}}, nil
281 case *protocol.RecentRouteSnapshot:
282 if m == nil {
283 return nil, ErrInvalidMessage
284 }
285 return encodeProtoClient(*m)
286 case protocol.RouteNavigationFailure:
287 converted, err := navigationFailureToWire(m)
288 if err != nil {
289 return nil, err
290 }
291 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RouteNavigationFailure{RouteNavigationFailure: converted}}, nil
292 case *protocol.RouteNavigationFailure:
293 if m == nil {
294 return nil, ErrInvalidMessage
295 }
296 return encodeProtoClient(*m)
297 case protocol.SessionCreationFailure:
298 converted, err := sessionCreationFailureToWire(m)
299 if err != nil {
300 return nil, err
301 }
302 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_SessionCreationFailure{SessionCreationFailure: converted}}, nil
303 case *protocol.SessionCreationFailure:
304 if m == nil {
305 return nil, ErrInvalidMessage
306 }
307 return encodeProtoClient(*m)
308 default:
309 return nil, ErrWrongDirection
310 }
311}
312
313func encodeProtoServer(message protocol.ServerMessage) (*wire.ServerEnvelope, error) {
314 switch m := message.(type) {
315 case protocol.AttachmentSuspended:
316 converted, err := attachmentSuspendedToWire(m)
317 if err != nil {
318 return nil, err
319 }
320 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_AttachmentSuspended{AttachmentSuspended: converted}}, nil
321 case *protocol.AttachmentSuspended:
322 if m == nil {
323 return nil, ErrInvalidMessage
324 }
325 return encodeProtoServer(*m)
326 case protocol.AttachmentActivated:
327 converted, err := attachmentActivatedToWire(m)
328 if err != nil {
329 return nil, err
330 }
331 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_AttachmentActivated{AttachmentActivated: converted}}, nil
332 case *protocol.AttachmentActivated:
333 if m == nil {
334 return nil, ErrInvalidMessage
335 }
336 return encodeProtoServer(*m)
337 case protocol.Welcome:
338 converted, err := welcomeToWire(m)
339 if err != nil {
340 return nil, err
341 }
342 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Welcome{Welcome: converted}}, nil
343 case *protocol.Welcome:
344 if m == nil {
345 return nil, ErrInvalidMessage
346 }
347 return encodeProtoServer(*m)
348 case protocol.ErrorMsg:
349 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Error{Error: errorToWire(m)}}, nil
350 case *protocol.ErrorMsg:
351 if m == nil {
352 return nil, ErrInvalidMessage
353 }
354 return encodeProtoServer(*m)
355 case protocol.Output:
356 converted, err := outputToWire(m)
357 if err != nil {
358 return nil, err
359 }
360 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Output{Output: converted}}, nil
361 case *protocol.Output:
362 if m == nil {
363 return nil, ErrInvalidMessage
364 }
365 return encodeProtoServer(*m)
366 case protocol.Detached:
367 converted, err := detachedToWire(m)
368 if err != nil {
369 return nil, err
370 }
371 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Detached{Detached: converted}}, nil
372 case *protocol.Detached:
373 if m == nil {
374 return nil, ErrInvalidMessage
375 }
376 return encodeProtoServer(*m)
377 case protocol.Pong:
378 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Pong{Pong: &wire.Pong{}}}, nil
379 case *protocol.Pong:
380 if m == nil {
381 return nil, ErrInvalidMessage
382 }
383 return encodeProtoServer(*m)
384 case protocol.Sessions:
385 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Sessions{Sessions: sessionsToWire(m)}}, nil
386 case *protocol.Sessions:
387 if m == nil {
388 return nil, ErrInvalidMessage
389 }
390 return encodeProtoServer(*m)
391 case protocol.CommandResult:
392 converted, err := commandResultToWire(m)
393 if err != nil {
394 return nil, err
395 }
396 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_CommandResult{CommandResult: converted}}, nil
397 case protocol.KillResult:
398 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_KillResult{KillResult: killResultToWire(m)}}, nil
399 case *protocol.KillResult:
400 if m == nil {
401 return nil, ErrInvalidMessage
402 }
403 return encodeProtoServer(*m)
404 case *protocol.CommandResult:
405 if m == nil {
406 return nil, ErrInvalidMessage
407 }
408 return encodeProtoServer(*m)
409 case protocol.AttachTarget:
410 converted, err := attachTargetToWire(m)
411 if err != nil {
412 return nil, err
413 }
414 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_AttachTarget{AttachTarget: converted}}, nil
415 case *protocol.AttachTarget:
416 if m == nil {
417 return nil, ErrInvalidMessage
418 }
419 return encodeProtoServer(*m)
420 case protocol.RemotePreview:
421 converted, err := remotePreviewToWire(m)
422 if err != nil {
423 return nil, err
424 }
425 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RemotePreview{RemotePreview: converted}}, nil
426 case *protocol.RemotePreview:
427 if m == nil {
428 return nil, ErrInvalidMessage
429 }
430 return encodeProtoServer(*m)
431 case protocol.CommittedRouteIdentity:
432 converted, err := committedIdentityToWire(m)
433 if err != nil {
434 return nil, err
435 }
436 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_CommittedRouteIdentity{CommittedRouteIdentity: converted}}, nil
437 case *protocol.CommittedRouteIdentity:
438 if m == nil {
439 return nil, ErrInvalidMessage
440 }
441 return encodeProtoServer(*m)
442 case protocol.RouteNavigationAction:
443 converted, err := routeNavigationActionToWire(m)
444 if err != nil {
445 return nil, err
446 }
447 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteNavigationAction{RouteNavigationAction: converted}}, nil
448 case *protocol.RouteNavigationAction:
449 if m == nil {
450 return nil, ErrInvalidMessage
451 }
452 return encodeProtoServer(*m)
453 case protocol.RouteCreateSessionAction:
454 converted, err := routeCreateSessionActionToWire(m)
455 if err != nil {
456 return nil, err
457 }
458 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteCreateSessionAction{RouteCreateSessionAction: converted}}, nil
459 case *protocol.RouteCreateSessionAction:
460 if m == nil {
461 return nil, ErrInvalidMessage
462 }
463 return encodeProtoServer(*m)
464 case protocol.RouteNavigationFailure:
465 converted, err := navigationFailureToWire(m)
466 if err != nil {
467 return nil, err
468 }
469 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteNavigationFailure{RouteNavigationFailure: converted}}, nil
470 case *protocol.RouteNavigationFailure:
471 if m == nil {
472 return nil, ErrInvalidMessage
473 }
474 return encodeProtoServer(*m)
475 case protocol.RouteRetired:
476 converted, err := routeRetiredToWire(m)
477 if err != nil {
478 return nil, err
479 }
480 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteRetired{RouteRetired: converted}}, nil
481 case *protocol.RouteRetired:
482 if m == nil {
483 return nil, ErrInvalidMessage
484 }
485 return encodeProtoServer(*m)
486 case protocol.RoutePosition:
487 converted, err := routePositionToWire(m)
488 if err != nil {
489 return nil, err
490 }
491 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RoutePosition{RoutePosition: converted}}, nil
492 case *protocol.RoutePosition:
493 if m == nil {
494 return nil, ErrInvalidMessage
495 }
496 return encodeProtoServer(*m)
497 case protocol.SamePeerSwitchFailure:
498 converted, err := samePeerSwitchFailureToWire(m)
499 if err != nil {
500 return nil, err
501 }
502 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_SamePeerSwitchFailure{SamePeerSwitchFailure: converted}}, nil
503 case *protocol.SamePeerSwitchFailure:
504 if m == nil {
505 return nil, ErrInvalidMessage
506 }
507 return encodeProtoServer(*m)
508 case protocol.UIReceipt:
509 converted, err := uiReceiptToWire(m)
510 if err != nil {
511 return nil, err
512 }
513 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_UiReceipt{UiReceipt: converted}}, nil
514 case *protocol.UIReceipt:
515 if m == nil {
516 return nil, ErrInvalidMessage
517 }
518 return encodeProtoServer(*m)
519 case protocol.UIViewUpdate:
520 converted, err := uiViewUpdateToWire(m)
521 if err != nil {
522 return nil, err
523 }
524 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_UiViewUpdate{UiViewUpdate: converted}}, nil
525 case *protocol.UIViewUpdate:
526 if m == nil {
527 return nil, ErrInvalidMessage
528 }
529 return encodeProtoServer(*m)
530 case protocol.NavigationInventoryResponse:
531 converted, err := inventoryResponseToWire(m)
532 if err != nil {
533 return nil, err
534 }
535 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_NavigationInventoryResponse{NavigationInventoryResponse: converted}}, nil
536 case *protocol.NavigationInventoryResponse:
537 if m == nil {
538 return nil, ErrInvalidMessage
539 }
540 return encodeProtoServer(*m)
541 case protocol.NavigationInventoryDemand:
542 converted, err := inventoryDemandToWire(m)
543 if err != nil {
544 return nil, err
545 }
546 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_NavigationInventoryDemand{NavigationInventoryDemand: converted}}, nil
547 case *protocol.NavigationInventoryDemand:
548 if m == nil {
549 return nil, ErrInvalidMessage
550 }
551 return encodeProtoServer(*m)
552 case protocol.NavigationInventorySelection:
553 converted, err := inventorySelectionToWire(m)
554 if err != nil {
555 return nil, err
556 }
557 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_NavigationInventorySelection{NavigationInventorySelection: converted}}, nil
558 case *protocol.NavigationInventorySelection:
559 if m == nil {
560 return nil, ErrInvalidMessage
561 }
562 return encodeProtoServer(*m)
563 case protocol.PickerOffer:
564 converted, err := pickerOfferToWire(m)
565 if err != nil {
566 return nil, err
567 }
568 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerOffer{PickerOffer: converted}}, nil
569 case *protocol.PickerOffer:
570 if m == nil {
571 return nil, ErrInvalidMessage
572 }
573 return encodeProtoServer(*m)
574 case protocol.PickerSnapshot:
575 converted, err := pickerSnapshotToWire(m)
576 if err != nil {
577 return nil, err
578 }
579 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerSnapshot{PickerSnapshot: converted}}, nil
580 case *protocol.PickerSnapshot:
581 if m == nil {
582 return nil, ErrInvalidMessage
583 }
584 return encodeProtoServer(*m)
585 case protocol.PickerClosed:
586 converted, err := pickerClosedToWire(m)
587 if err != nil {
588 return nil, err
589 }
590 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerClosed{PickerClosed: converted}}, nil
591 case *protocol.PickerClosed:
592 if m == nil {
593 return nil, ErrInvalidMessage
594 }
595 return encodeProtoServer(*m)
596 case protocol.PickerResult:
597 converted, err := pickerResultToWire(m)
598 if err != nil {
599 return nil, err
600 }
601 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerResult{PickerResult: converted}}, nil
602 case *protocol.PickerResult:
603 if m == nil {
604 return nil, ErrInvalidMessage
605 }
606 return encodeProtoServer(*m)
607 case protocol.PickerFailure:
608 converted, err := pickerFailureToWire(m)
609 if err != nil {
610 return nil, err
611 }
612 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerFailure{PickerFailure: converted}}, nil
613 case *protocol.PickerFailure:
614 if m == nil {
615 return nil, ErrInvalidMessage
616 }
617 return encodeProtoServer(*m)
618 default:
619 return nil, ErrWrongDirection
620 }
621}
622
623// decodeProtoClient unwraps one scanned client envelope into its semantic
624// message. The payload must already have passed wire.ScanEnvelope.
625func decodeProtoClient(envelope *wire.ClientEnvelope) (protocol.ClientMessage, error) {
626 if envelope == nil {
627 return nil, ErrInvalidMessage
628 }
629 switch payload := envelope.Payload.(type) {
630 case *wire.ClientEnvelope_SuspendAttachment:
631 return suspendAttachmentFromWire(payload.SuspendAttachment)
632 case *wire.ClientEnvelope_ActivateAttachment:
633 return activateAttachmentFromWire(payload.ActivateAttachment)
634 case *wire.ClientEnvelope_Hello:
635 return helloFromWire(payload.Hello)
636 case *wire.ClientEnvelope_Input:
637 return inputFromWire(payload.Input)
638 case *wire.ClientEnvelope_Resize:
639 return resizeFromWire(payload.Resize)
640 case *wire.ClientEnvelope_Detach:
641 return protocol.Detach{Closed: payload.Detach.GetClosed()}, nil
642 case *wire.ClientEnvelope_Ping:
643 return protocol.Ping{}, nil
644 case *wire.ClientEnvelope_List:
645 return protocol.List{}, nil
646 case *wire.ClientEnvelope_Kill:
647 return killFromWire(payload.Kill)
648 case *wire.ClientEnvelope_Theme:
649 return themeFromWire(payload.Theme)
650 case *wire.ClientEnvelope_Ack:
651 return ackFromWire(payload.Ack)
652 case *wire.ClientEnvelope_ImagePush:
653 return imagePushFromWire(payload.ImagePush)
654 case *wire.ClientEnvelope_ClientNotice:
655 return clientNoticeFromWire(payload.ClientNotice)
656 case *wire.ClientEnvelope_CommandRequest:
657 return commandRequestFromWire(payload.CommandRequest)
658 case *wire.ClientEnvelope_OutputResetRequest:
659 return protocol.OutputResetRequest{}, nil
660 case *wire.ClientEnvelope_UiFence:
661 return uiFenceFromWire(payload.UiFence)
662 case *wire.ClientEnvelope_SelectTab:
663 return selectTabFromWire(payload.SelectTab)
664 case *wire.ClientEnvelope_TerminalFocus:
665 return terminalFocusFromWire(payload.TerminalFocus)
666 case *wire.ClientEnvelope_ModifierState:
667 if payload.ModifierState == nil {
668 return nil, errProtoConvertRange
669 }
670 return protocol.ModifierState{Ctrl: payload.ModifierState.GetCtrl()}, nil
671 case *wire.ClientEnvelope_RemotePreviewWatch:
672 return remotePreviewWatchFromWire(payload.RemotePreviewWatch)
673 case *wire.ClientEnvelope_RouteAttentionSubscription:
674 return attentionSubscriptionFromWire(payload.RouteAttentionSubscription)
675 case *wire.ClientEnvelope_SamePeerSwitchRequest:
676 return samePeerSwitchRequestFromWire(payload.SamePeerSwitchRequest)
677 case *wire.ClientEnvelope_RecentRouteSnapshot:
678 return recentRouteSnapshotFromWire(payload.RecentRouteSnapshot)
679 case *wire.ClientEnvelope_RouteNavigationFailure:
680 return navigationFailureFromWire(payload.RouteNavigationFailure)
681 case *wire.ClientEnvelope_SessionCreationFailure:
682 return sessionCreationFailureFromWire(payload.SessionCreationFailure)
683 case *wire.ClientEnvelope_NavigationInventoryRequest:
684 return inventoryRequestFromWire(payload.NavigationInventoryRequest)
685 case *wire.ClientEnvelope_NavigationInventoryPublication:
686 return inventoryPublicationFromWire(payload.NavigationInventoryPublication)
687 case *wire.ClientEnvelope_NavigationInventoryFailure:
688 return inventoryFailureFromWire(payload.NavigationInventoryFailure)
689 case *wire.ClientEnvelope_PickerClose:
690 return pickerCloseFromWire(payload.PickerClose)
691 case *wire.ClientEnvelope_PickerSelection:
692 return pickerSelectionFromWire(payload.PickerSelection)
693 default:
694 return nil, ErrWrongDirection
695 }
696}
697
698// decodeProtoServer unwraps one scanned server envelope into its semantic
699// message. The payload must already have passed wire.ScanEnvelope.
700func decodeProtoServer(envelope *wire.ServerEnvelope) (protocol.ServerMessage, error) {
701 if envelope == nil {
702 return nil, ErrInvalidMessage
703 }
704 switch payload := envelope.Payload.(type) {
705 case *wire.ServerEnvelope_AttachmentSuspended:
706 return attachmentSuspendedFromWire(payload.AttachmentSuspended)
707 case *wire.ServerEnvelope_AttachmentActivated:
708 return attachmentActivatedFromWire(payload.AttachmentActivated)
709 case *wire.ServerEnvelope_Welcome:
710 return welcomeFromWire(payload.Welcome)
711 case *wire.ServerEnvelope_Error:
712 return errorFromWire(payload.Error)
713 case *wire.ServerEnvelope_Output:
714 return outputFromWire(payload.Output)
715 case *wire.ServerEnvelope_Detached:
716 return detachedFromWire(payload.Detached)
717 case *wire.ServerEnvelope_Pong:
718 return protocol.Pong{}, nil
719 case *wire.ServerEnvelope_Sessions:
720 return sessionsFromWire(payload.Sessions)
721 case *wire.ServerEnvelope_CommandResult:
722 return commandResultFromWire(payload.CommandResult)
723 case *wire.ServerEnvelope_KillResult:
724 return killResultFromWire(payload.KillResult)
725 case *wire.ServerEnvelope_AttachTarget:
726 return attachTargetFromWire(payload.AttachTarget)
727 case *wire.ServerEnvelope_RemotePreview:
728 return remotePreviewFromWire(payload.RemotePreview)
729 case *wire.ServerEnvelope_CommittedRouteIdentity:
730 return committedIdentityFromWire(payload.CommittedRouteIdentity)
731 case *wire.ServerEnvelope_RouteNavigationAction:
732 return routeNavigationActionFromWire(payload.RouteNavigationAction)
733 case *wire.ServerEnvelope_RouteCreateSessionAction:
734 return routeCreateSessionActionFromWire(payload.RouteCreateSessionAction)
735 case *wire.ServerEnvelope_RouteNavigationFailure:
736 return navigationFailureFromWire(payload.RouteNavigationFailure)
737 case *wire.ServerEnvelope_RoutePosition:
738 return routePositionFromWire(payload.RoutePosition)
739 case *wire.ServerEnvelope_RouteRetired:
740 return routeRetiredFromWire(payload.RouteRetired)
741 case *wire.ServerEnvelope_SamePeerSwitchFailure:
742 return samePeerSwitchFailureFromWire(payload.SamePeerSwitchFailure)
743 case *wire.ServerEnvelope_UiReceipt:
744 return uiReceiptFromWire(payload.UiReceipt)
745 case *wire.ServerEnvelope_UiViewUpdate:
746 return uiViewUpdateFromWire(payload.UiViewUpdate)
747 case *wire.ServerEnvelope_NavigationInventoryResponse:
748 return inventoryResponseFromWire(payload.NavigationInventoryResponse)
749 case *wire.ServerEnvelope_NavigationInventoryDemand:
750 return inventoryDemandFromWire(payload.NavigationInventoryDemand)
751 case *wire.ServerEnvelope_NavigationInventorySelection:
752 return inventorySelectionFromWire(payload.NavigationInventorySelection)
753 case *wire.ServerEnvelope_PickerOffer:
754 return pickerOfferFromWire(payload.PickerOffer)
755 case *wire.ServerEnvelope_PickerSnapshot:
756 return pickerSnapshotFromWire(payload.PickerSnapshot)
757 case *wire.ServerEnvelope_PickerClosed:
758 return pickerClosedFromWire(payload.PickerClosed)
759 case *wire.ServerEnvelope_PickerResult:
760 return pickerResultFromWire(payload.PickerResult)
761 case *wire.ServerEnvelope_PickerFailure:
762 return pickerFailureFromWire(payload.PickerFailure)
763 default:
764 return nil, ErrWrongDirection
765 }
766}