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.UIFence:
174 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_UiFence{UiFence: uiFenceToWire(m)}}, nil
175 case *protocol.UIFence:
176 if m == nil {
177 return nil, ErrInvalidMessage
178 }
179 return encodeProtoClient(*m)
180 case protocol.RemotePreviewWatch:
181 converted, err := remotePreviewWatchToWire(m)
182 if err != nil {
183 return nil, err
184 }
185 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RemotePreviewWatch{RemotePreviewWatch: converted}}, nil
186 case *protocol.RemotePreviewWatch:
187 if m == nil {
188 return nil, ErrInvalidMessage
189 }
190 return encodeProtoClient(*m)
191 case protocol.RouteAttentionSubscription:
192 converted, err := attentionSubscriptionToWire(m)
193 if err != nil {
194 return nil, err
195 }
196 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RouteAttentionSubscription{RouteAttentionSubscription: converted}}, nil
197 case *protocol.RouteAttentionSubscription:
198 if m == nil {
199 return nil, ErrInvalidMessage
200 }
201 return encodeProtoClient(*m)
202 case protocol.SamePeerSwitchRequest:
203 converted, err := samePeerSwitchRequestToWire(m)
204 if err != nil {
205 return nil, err
206 }
207 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_SamePeerSwitchRequest{SamePeerSwitchRequest: converted}}, nil
208 case *protocol.SamePeerSwitchRequest:
209 if m == nil {
210 return nil, ErrInvalidMessage
211 }
212 return encodeProtoClient(*m)
213 case protocol.NavigationInventoryRequest:
214 converted, err := inventoryRequestToWire(m)
215 if err != nil {
216 return nil, err
217 }
218 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_NavigationInventoryRequest{NavigationInventoryRequest: converted}}, nil
219 case *protocol.NavigationInventoryRequest:
220 if m == nil {
221 return nil, ErrInvalidMessage
222 }
223 return encodeProtoClient(*m)
224 case protocol.NavigationInventoryPublication:
225 converted, err := inventoryPublicationToWire(m)
226 if err != nil {
227 return nil, err
228 }
229 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_NavigationInventoryPublication{NavigationInventoryPublication: converted}}, nil
230 case *protocol.NavigationInventoryPublication:
231 if m == nil {
232 return nil, ErrInvalidMessage
233 }
234 return encodeProtoClient(*m)
235 case protocol.NavigationInventoryFailure:
236 converted, err := inventoryFailureToWire(m)
237 if err != nil {
238 return nil, err
239 }
240 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_NavigationInventoryFailure{NavigationInventoryFailure: converted}}, nil
241 case *protocol.NavigationInventoryFailure:
242 if m == nil {
243 return nil, ErrInvalidMessage
244 }
245 return encodeProtoClient(*m)
246 case protocol.PickerClose:
247 converted, err := pickerCloseToWire(m)
248 if err != nil {
249 return nil, err
250 }
251 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_PickerClose{PickerClose: converted}}, nil
252 case *protocol.PickerClose:
253 if m == nil {
254 return nil, ErrInvalidMessage
255 }
256 return encodeProtoClient(*m)
257 case protocol.PickerSelection:
258 converted, err := pickerSelectionToWire(m)
259 if err != nil {
260 return nil, err
261 }
262 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_PickerSelection{PickerSelection: converted}}, nil
263 case *protocol.PickerSelection:
264 if m == nil {
265 return nil, ErrInvalidMessage
266 }
267 return encodeProtoClient(*m)
268 case protocol.RecentRouteSnapshot:
269 converted, err := recentRouteSnapshotToWire(m)
270 if err != nil {
271 return nil, err
272 }
273 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RecentRouteSnapshot{RecentRouteSnapshot: converted}}, nil
274 case *protocol.RecentRouteSnapshot:
275 if m == nil {
276 return nil, ErrInvalidMessage
277 }
278 return encodeProtoClient(*m)
279 case protocol.RouteNavigationFailure:
280 converted, err := navigationFailureToWire(m)
281 if err != nil {
282 return nil, err
283 }
284 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_RouteNavigationFailure{RouteNavigationFailure: converted}}, nil
285 case *protocol.RouteNavigationFailure:
286 if m == nil {
287 return nil, ErrInvalidMessage
288 }
289 return encodeProtoClient(*m)
290 case protocol.SessionCreationFailure:
291 converted, err := sessionCreationFailureToWire(m)
292 if err != nil {
293 return nil, err
294 }
295 return &wire.ClientEnvelope{Payload: &wire.ClientEnvelope_SessionCreationFailure{SessionCreationFailure: converted}}, nil
296 case *protocol.SessionCreationFailure:
297 if m == nil {
298 return nil, ErrInvalidMessage
299 }
300 return encodeProtoClient(*m)
301 default:
302 return nil, ErrWrongDirection
303 }
304}
305
306func encodeProtoServer(message protocol.ServerMessage) (*wire.ServerEnvelope, error) {
307 switch m := message.(type) {
308 case protocol.AttachmentSuspended:
309 converted, err := attachmentSuspendedToWire(m)
310 if err != nil {
311 return nil, err
312 }
313 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_AttachmentSuspended{AttachmentSuspended: converted}}, nil
314 case *protocol.AttachmentSuspended:
315 if m == nil {
316 return nil, ErrInvalidMessage
317 }
318 return encodeProtoServer(*m)
319 case protocol.AttachmentActivated:
320 converted, err := attachmentActivatedToWire(m)
321 if err != nil {
322 return nil, err
323 }
324 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_AttachmentActivated{AttachmentActivated: converted}}, nil
325 case *protocol.AttachmentActivated:
326 if m == nil {
327 return nil, ErrInvalidMessage
328 }
329 return encodeProtoServer(*m)
330 case protocol.Welcome:
331 converted, err := welcomeToWire(m)
332 if err != nil {
333 return nil, err
334 }
335 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Welcome{Welcome: converted}}, nil
336 case *protocol.Welcome:
337 if m == nil {
338 return nil, ErrInvalidMessage
339 }
340 return encodeProtoServer(*m)
341 case protocol.ErrorMsg:
342 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Error{Error: errorToWire(m)}}, nil
343 case *protocol.ErrorMsg:
344 if m == nil {
345 return nil, ErrInvalidMessage
346 }
347 return encodeProtoServer(*m)
348 case protocol.Output:
349 converted, err := outputToWire(m)
350 if err != nil {
351 return nil, err
352 }
353 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Output{Output: converted}}, nil
354 case *protocol.Output:
355 if m == nil {
356 return nil, ErrInvalidMessage
357 }
358 return encodeProtoServer(*m)
359 case protocol.Detached:
360 converted, err := detachedToWire(m)
361 if err != nil {
362 return nil, err
363 }
364 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Detached{Detached: converted}}, nil
365 case *protocol.Detached:
366 if m == nil {
367 return nil, ErrInvalidMessage
368 }
369 return encodeProtoServer(*m)
370 case protocol.Pong:
371 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Pong{Pong: &wire.Pong{}}}, nil
372 case *protocol.Pong:
373 if m == nil {
374 return nil, ErrInvalidMessage
375 }
376 return encodeProtoServer(*m)
377 case protocol.Sessions:
378 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_Sessions{Sessions: sessionsToWire(m)}}, nil
379 case *protocol.Sessions:
380 if m == nil {
381 return nil, ErrInvalidMessage
382 }
383 return encodeProtoServer(*m)
384 case protocol.CommandResult:
385 converted, err := commandResultToWire(m)
386 if err != nil {
387 return nil, err
388 }
389 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_CommandResult{CommandResult: converted}}, nil
390 case protocol.KillResult:
391 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_KillResult{KillResult: killResultToWire(m)}}, nil
392 case *protocol.KillResult:
393 if m == nil {
394 return nil, ErrInvalidMessage
395 }
396 return encodeProtoServer(*m)
397 case *protocol.CommandResult:
398 if m == nil {
399 return nil, ErrInvalidMessage
400 }
401 return encodeProtoServer(*m)
402 case protocol.AttachTarget:
403 converted, err := attachTargetToWire(m)
404 if err != nil {
405 return nil, err
406 }
407 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_AttachTarget{AttachTarget: converted}}, nil
408 case *protocol.AttachTarget:
409 if m == nil {
410 return nil, ErrInvalidMessage
411 }
412 return encodeProtoServer(*m)
413 case protocol.RemotePreview:
414 converted, err := remotePreviewToWire(m)
415 if err != nil {
416 return nil, err
417 }
418 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RemotePreview{RemotePreview: converted}}, nil
419 case *protocol.RemotePreview:
420 if m == nil {
421 return nil, ErrInvalidMessage
422 }
423 return encodeProtoServer(*m)
424 case protocol.CommittedRouteIdentity:
425 converted, err := committedIdentityToWire(m)
426 if err != nil {
427 return nil, err
428 }
429 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_CommittedRouteIdentity{CommittedRouteIdentity: converted}}, nil
430 case *protocol.CommittedRouteIdentity:
431 if m == nil {
432 return nil, ErrInvalidMessage
433 }
434 return encodeProtoServer(*m)
435 case protocol.RouteNavigationAction:
436 converted, err := routeNavigationActionToWire(m)
437 if err != nil {
438 return nil, err
439 }
440 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteNavigationAction{RouteNavigationAction: converted}}, nil
441 case *protocol.RouteNavigationAction:
442 if m == nil {
443 return nil, ErrInvalidMessage
444 }
445 return encodeProtoServer(*m)
446 case protocol.RouteCreateSessionAction:
447 converted, err := routeCreateSessionActionToWire(m)
448 if err != nil {
449 return nil, err
450 }
451 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteCreateSessionAction{RouteCreateSessionAction: converted}}, nil
452 case *protocol.RouteCreateSessionAction:
453 if m == nil {
454 return nil, ErrInvalidMessage
455 }
456 return encodeProtoServer(*m)
457 case protocol.RouteNavigationFailure:
458 converted, err := navigationFailureToWire(m)
459 if err != nil {
460 return nil, err
461 }
462 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteNavigationFailure{RouteNavigationFailure: converted}}, nil
463 case *protocol.RouteNavigationFailure:
464 if m == nil {
465 return nil, ErrInvalidMessage
466 }
467 return encodeProtoServer(*m)
468 case protocol.RouteRetired:
469 converted, err := routeRetiredToWire(m)
470 if err != nil {
471 return nil, err
472 }
473 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RouteRetired{RouteRetired: converted}}, nil
474 case *protocol.RouteRetired:
475 if m == nil {
476 return nil, ErrInvalidMessage
477 }
478 return encodeProtoServer(*m)
479 case protocol.RoutePosition:
480 converted, err := routePositionToWire(m)
481 if err != nil {
482 return nil, err
483 }
484 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_RoutePosition{RoutePosition: converted}}, nil
485 case *protocol.RoutePosition:
486 if m == nil {
487 return nil, ErrInvalidMessage
488 }
489 return encodeProtoServer(*m)
490 case protocol.SamePeerSwitchFailure:
491 converted, err := samePeerSwitchFailureToWire(m)
492 if err != nil {
493 return nil, err
494 }
495 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_SamePeerSwitchFailure{SamePeerSwitchFailure: converted}}, nil
496 case *protocol.SamePeerSwitchFailure:
497 if m == nil {
498 return nil, ErrInvalidMessage
499 }
500 return encodeProtoServer(*m)
501 case protocol.UIReceipt:
502 converted, err := uiReceiptToWire(m)
503 if err != nil {
504 return nil, err
505 }
506 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_UiReceipt{UiReceipt: converted}}, nil
507 case *protocol.UIReceipt:
508 if m == nil {
509 return nil, ErrInvalidMessage
510 }
511 return encodeProtoServer(*m)
512 case protocol.UIViewUpdate:
513 converted, err := uiViewUpdateToWire(m)
514 if err != nil {
515 return nil, err
516 }
517 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_UiViewUpdate{UiViewUpdate: converted}}, nil
518 case *protocol.UIViewUpdate:
519 if m == nil {
520 return nil, ErrInvalidMessage
521 }
522 return encodeProtoServer(*m)
523 case protocol.NavigationInventoryResponse:
524 converted, err := inventoryResponseToWire(m)
525 if err != nil {
526 return nil, err
527 }
528 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_NavigationInventoryResponse{NavigationInventoryResponse: converted}}, nil
529 case *protocol.NavigationInventoryResponse:
530 if m == nil {
531 return nil, ErrInvalidMessage
532 }
533 return encodeProtoServer(*m)
534 case protocol.NavigationInventoryDemand:
535 converted, err := inventoryDemandToWire(m)
536 if err != nil {
537 return nil, err
538 }
539 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_NavigationInventoryDemand{NavigationInventoryDemand: converted}}, nil
540 case *protocol.NavigationInventoryDemand:
541 if m == nil {
542 return nil, ErrInvalidMessage
543 }
544 return encodeProtoServer(*m)
545 case protocol.NavigationInventorySelection:
546 converted, err := inventorySelectionToWire(m)
547 if err != nil {
548 return nil, err
549 }
550 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_NavigationInventorySelection{NavigationInventorySelection: converted}}, nil
551 case *protocol.NavigationInventorySelection:
552 if m == nil {
553 return nil, ErrInvalidMessage
554 }
555 return encodeProtoServer(*m)
556 case protocol.PickerOffer:
557 converted, err := pickerOfferToWire(m)
558 if err != nil {
559 return nil, err
560 }
561 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerOffer{PickerOffer: converted}}, nil
562 case *protocol.PickerOffer:
563 if m == nil {
564 return nil, ErrInvalidMessage
565 }
566 return encodeProtoServer(*m)
567 case protocol.PickerSnapshot:
568 converted, err := pickerSnapshotToWire(m)
569 if err != nil {
570 return nil, err
571 }
572 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerSnapshot{PickerSnapshot: converted}}, nil
573 case *protocol.PickerSnapshot:
574 if m == nil {
575 return nil, ErrInvalidMessage
576 }
577 return encodeProtoServer(*m)
578 case protocol.PickerClosed:
579 converted, err := pickerClosedToWire(m)
580 if err != nil {
581 return nil, err
582 }
583 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerClosed{PickerClosed: converted}}, nil
584 case *protocol.PickerClosed:
585 if m == nil {
586 return nil, ErrInvalidMessage
587 }
588 return encodeProtoServer(*m)
589 case protocol.PickerResult:
590 converted, err := pickerResultToWire(m)
591 if err != nil {
592 return nil, err
593 }
594 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerResult{PickerResult: converted}}, nil
595 case *protocol.PickerResult:
596 if m == nil {
597 return nil, ErrInvalidMessage
598 }
599 return encodeProtoServer(*m)
600 case protocol.PickerFailure:
601 converted, err := pickerFailureToWire(m)
602 if err != nil {
603 return nil, err
604 }
605 return &wire.ServerEnvelope{Payload: &wire.ServerEnvelope_PickerFailure{PickerFailure: converted}}, nil
606 case *protocol.PickerFailure:
607 if m == nil {
608 return nil, ErrInvalidMessage
609 }
610 return encodeProtoServer(*m)
611 default:
612 return nil, ErrWrongDirection
613 }
614}
615
616// decodeProtoClient unwraps one scanned client envelope into its semantic
617// message. The payload must already have passed wire.ScanEnvelope.
618func decodeProtoClient(envelope *wire.ClientEnvelope) (protocol.ClientMessage, error) {
619 if envelope == nil {
620 return nil, ErrInvalidMessage
621 }
622 switch payload := envelope.Payload.(type) {
623 case *wire.ClientEnvelope_SuspendAttachment:
624 return suspendAttachmentFromWire(payload.SuspendAttachment)
625 case *wire.ClientEnvelope_ActivateAttachment:
626 return activateAttachmentFromWire(payload.ActivateAttachment)
627 case *wire.ClientEnvelope_Hello:
628 return helloFromWire(payload.Hello)
629 case *wire.ClientEnvelope_Input:
630 return inputFromWire(payload.Input)
631 case *wire.ClientEnvelope_Resize:
632 return resizeFromWire(payload.Resize)
633 case *wire.ClientEnvelope_Detach:
634 return protocol.Detach{Closed: payload.Detach.GetClosed()}, nil
635 case *wire.ClientEnvelope_Ping:
636 return protocol.Ping{}, nil
637 case *wire.ClientEnvelope_List:
638 return protocol.List{}, nil
639 case *wire.ClientEnvelope_Kill:
640 return killFromWire(payload.Kill)
641 case *wire.ClientEnvelope_Theme:
642 return themeFromWire(payload.Theme)
643 case *wire.ClientEnvelope_Ack:
644 return ackFromWire(payload.Ack)
645 case *wire.ClientEnvelope_ImagePush:
646 return imagePushFromWire(payload.ImagePush)
647 case *wire.ClientEnvelope_ClientNotice:
648 return clientNoticeFromWire(payload.ClientNotice)
649 case *wire.ClientEnvelope_CommandRequest:
650 return commandRequestFromWire(payload.CommandRequest)
651 case *wire.ClientEnvelope_OutputResetRequest:
652 return protocol.OutputResetRequest{}, nil
653 case *wire.ClientEnvelope_UiFence:
654 return uiFenceFromWire(payload.UiFence)
655 case *wire.ClientEnvelope_SelectTab:
656 return selectTabFromWire(payload.SelectTab)
657 case *wire.ClientEnvelope_TerminalFocus:
658 return terminalFocusFromWire(payload.TerminalFocus)
659 case *wire.ClientEnvelope_RemotePreviewWatch:
660 return remotePreviewWatchFromWire(payload.RemotePreviewWatch)
661 case *wire.ClientEnvelope_RouteAttentionSubscription:
662 return attentionSubscriptionFromWire(payload.RouteAttentionSubscription)
663 case *wire.ClientEnvelope_SamePeerSwitchRequest:
664 return samePeerSwitchRequestFromWire(payload.SamePeerSwitchRequest)
665 case *wire.ClientEnvelope_RecentRouteSnapshot:
666 return recentRouteSnapshotFromWire(payload.RecentRouteSnapshot)
667 case *wire.ClientEnvelope_RouteNavigationFailure:
668 return navigationFailureFromWire(payload.RouteNavigationFailure)
669 case *wire.ClientEnvelope_SessionCreationFailure:
670 return sessionCreationFailureFromWire(payload.SessionCreationFailure)
671 case *wire.ClientEnvelope_NavigationInventoryRequest:
672 return inventoryRequestFromWire(payload.NavigationInventoryRequest)
673 case *wire.ClientEnvelope_NavigationInventoryPublication:
674 return inventoryPublicationFromWire(payload.NavigationInventoryPublication)
675 case *wire.ClientEnvelope_NavigationInventoryFailure:
676 return inventoryFailureFromWire(payload.NavigationInventoryFailure)
677 case *wire.ClientEnvelope_PickerClose:
678 return pickerCloseFromWire(payload.PickerClose)
679 case *wire.ClientEnvelope_PickerSelection:
680 return pickerSelectionFromWire(payload.PickerSelection)
681 default:
682 return nil, ErrWrongDirection
683 }
684}
685
686// decodeProtoServer unwraps one scanned server envelope into its semantic
687// message. The payload must already have passed wire.ScanEnvelope.
688func decodeProtoServer(envelope *wire.ServerEnvelope) (protocol.ServerMessage, error) {
689 if envelope == nil {
690 return nil, ErrInvalidMessage
691 }
692 switch payload := envelope.Payload.(type) {
693 case *wire.ServerEnvelope_AttachmentSuspended:
694 return attachmentSuspendedFromWire(payload.AttachmentSuspended)
695 case *wire.ServerEnvelope_AttachmentActivated:
696 return attachmentActivatedFromWire(payload.AttachmentActivated)
697 case *wire.ServerEnvelope_Welcome:
698 return welcomeFromWire(payload.Welcome)
699 case *wire.ServerEnvelope_Error:
700 return errorFromWire(payload.Error)
701 case *wire.ServerEnvelope_Output:
702 return outputFromWire(payload.Output)
703 case *wire.ServerEnvelope_Detached:
704 return detachedFromWire(payload.Detached)
705 case *wire.ServerEnvelope_Pong:
706 return protocol.Pong{}, nil
707 case *wire.ServerEnvelope_Sessions:
708 return sessionsFromWire(payload.Sessions)
709 case *wire.ServerEnvelope_CommandResult:
710 return commandResultFromWire(payload.CommandResult)
711 case *wire.ServerEnvelope_KillResult:
712 return killResultFromWire(payload.KillResult)
713 case *wire.ServerEnvelope_AttachTarget:
714 return attachTargetFromWire(payload.AttachTarget)
715 case *wire.ServerEnvelope_RemotePreview:
716 return remotePreviewFromWire(payload.RemotePreview)
717 case *wire.ServerEnvelope_CommittedRouteIdentity:
718 return committedIdentityFromWire(payload.CommittedRouteIdentity)
719 case *wire.ServerEnvelope_RouteNavigationAction:
720 return routeNavigationActionFromWire(payload.RouteNavigationAction)
721 case *wire.ServerEnvelope_RouteCreateSessionAction:
722 return routeCreateSessionActionFromWire(payload.RouteCreateSessionAction)
723 case *wire.ServerEnvelope_RouteNavigationFailure:
724 return navigationFailureFromWire(payload.RouteNavigationFailure)
725 case *wire.ServerEnvelope_RoutePosition:
726 return routePositionFromWire(payload.RoutePosition)
727 case *wire.ServerEnvelope_RouteRetired:
728 return routeRetiredFromWire(payload.RouteRetired)
729 case *wire.ServerEnvelope_SamePeerSwitchFailure:
730 return samePeerSwitchFailureFromWire(payload.SamePeerSwitchFailure)
731 case *wire.ServerEnvelope_UiReceipt:
732 return uiReceiptFromWire(payload.UiReceipt)
733 case *wire.ServerEnvelope_UiViewUpdate:
734 return uiViewUpdateFromWire(payload.UiViewUpdate)
735 case *wire.ServerEnvelope_NavigationInventoryResponse:
736 return inventoryResponseFromWire(payload.NavigationInventoryResponse)
737 case *wire.ServerEnvelope_NavigationInventoryDemand:
738 return inventoryDemandFromWire(payload.NavigationInventoryDemand)
739 case *wire.ServerEnvelope_NavigationInventorySelection:
740 return inventorySelectionFromWire(payload.NavigationInventorySelection)
741 case *wire.ServerEnvelope_PickerOffer:
742 return pickerOfferFromWire(payload.PickerOffer)
743 case *wire.ServerEnvelope_PickerSnapshot:
744 return pickerSnapshotFromWire(payload.PickerSnapshot)
745 case *wire.ServerEnvelope_PickerClosed:
746 return pickerClosedFromWire(payload.PickerClosed)
747 case *wire.ServerEnvelope_PickerResult:
748 return pickerResultFromWire(payload.PickerResult)
749 case *wire.ServerEnvelope_PickerFailure:
750 return pickerFailureFromWire(payload.PickerFailure)
751 default:
752 return nil, ErrWrongDirection
753 }
754}