x25_out.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * X.25 Packet Layer release 002
  4. *
  5. * This is ALPHA test software. This code may break your machine,
  6. * randomly fail to work with new releases, misbehave and/or generally
  7. * screw up. It might even work.
  8. *
  9. * This code REQUIRES 2.1.15 or higher
  10. *
  11. * History
  12. * X.25 001 Jonathan Naylor Started coding.
  13. * X.25 002 Jonathan Naylor New timer architecture.
  14. * 2000-09-04 Henner Eisen Prevented x25_output() skb leakage.
  15. * 2000-10-27 Henner Eisen MSG_DONTWAIT for fragment allocation.
  16. * 2000-11-10 Henner Eisen x25_send_iframe(): re-queued frames
  17. * needed cleaned seq-number fields.
  18. */
  19. #include <linux/slab.h>
  20. #include <linux/socket.h>
  21. #include <linux/kernel.h>
  22. #include <linux/string.h>
  23. #include <linux/skbuff.h>
  24. #include <net/sock.h>
  25. #include <net/x25.h>
  26. static int x25_pacsize_to_bytes(unsigned int pacsize)
  27. {
  28. int bytes = 1;
  29. if (!pacsize)
  30. return 128;
  31. while (pacsize-- > 0)
  32. bytes *= 2;
  33. return bytes;
  34. }
  35. /*
  36. * This is where all X.25 information frames pass.
  37. *
  38. * Returns the amount of user data bytes sent on success
  39. * or a negative error code on failure.
  40. */
  41. int x25_output(struct sock *sk, struct sk_buff *skb)
  42. {
  43. struct sk_buff *skbn;
  44. unsigned char header[X25_EXT_MIN_LEN];
  45. int err, frontlen, len;
  46. int sent=0, noblock = X25_SKB_CB(skb)->flags & MSG_DONTWAIT;
  47. struct x25_sock *x25 = x25_sk(sk);
  48. int header_len = x25->neighbour->extended ? X25_EXT_MIN_LEN :
  49. X25_STD_MIN_LEN;
  50. int max_len = x25_pacsize_to_bytes(x25->facilities.pacsize_out);
  51. if (skb->len - header_len > max_len) {
  52. /* Save a copy of the Header */
  53. skb_copy_from_linear_data(skb, header, header_len);
  54. skb_pull(skb, header_len);
  55. frontlen = skb_headroom(skb);
  56. while (skb->len > 0) {
  57. release_sock(sk);
  58. skbn = sock_alloc_send_skb(sk, frontlen + max_len,
  59. noblock, &err);
  60. lock_sock(sk);
  61. if (!skbn) {
  62. if (err == -EWOULDBLOCK && noblock){
  63. kfree_skb(skb);
  64. return sent;
  65. }
  66. SOCK_DEBUG(sk, "x25_output: fragment alloc"
  67. " failed, err=%d, %d bytes "
  68. "sent\n", err, sent);
  69. return err;
  70. }
  71. skb_reserve(skbn, frontlen);
  72. len = max_len > skb->len ? skb->len : max_len;
  73. /* Copy the user data */
  74. skb_copy_from_linear_data(skb, skb_put(skbn, len), len);
  75. skb_pull(skb, len);
  76. /* Duplicate the Header */
  77. skb_push(skbn, header_len);
  78. skb_copy_to_linear_data(skbn, header, header_len);
  79. if (skb->len > 0) {
  80. if (x25->neighbour->extended)
  81. skbn->data[3] |= X25_EXT_M_BIT;
  82. else
  83. skbn->data[2] |= X25_STD_M_BIT;
  84. }
  85. skb_queue_tail(&sk->sk_write_queue, skbn);
  86. sent += len;
  87. }
  88. kfree_skb(skb);
  89. } else {
  90. skb_queue_tail(&sk->sk_write_queue, skb);
  91. sent = skb->len - header_len;
  92. }
  93. return sent;
  94. }
  95. /*
  96. * This procedure is passed a buffer descriptor for an iframe. It builds
  97. * the rest of the control part of the frame and then writes it out.
  98. */
  99. static void x25_send_iframe(struct sock *sk, struct sk_buff *skb)
  100. {
  101. struct x25_sock *x25 = x25_sk(sk);
  102. if (!skb)
  103. return;
  104. if (x25->neighbour->extended) {
  105. skb->data[2] = (x25->vs << 1) & 0xFE;
  106. skb->data[3] &= X25_EXT_M_BIT;
  107. skb->data[3] |= (x25->vr << 1) & 0xFE;
  108. } else {
  109. skb->data[2] &= X25_STD_M_BIT;
  110. skb->data[2] |= (x25->vs << 1) & 0x0E;
  111. skb->data[2] |= (x25->vr << 5) & 0xE0;
  112. }
  113. x25_transmit_link(skb, x25->neighbour);
  114. }
  115. void x25_kick(struct sock *sk)
  116. {
  117. struct sk_buff *skb, *skbn;
  118. unsigned short start, end;
  119. int modulus;
  120. struct x25_sock *x25 = x25_sk(sk);
  121. if (x25->state != X25_STATE_3)
  122. return;
  123. /*
  124. * Transmit interrupt data.
  125. */
  126. if (skb_peek(&x25->interrupt_out_queue) != NULL &&
  127. !test_and_set_bit(X25_INTERRUPT_FLAG, &x25->flags)) {
  128. skb = skb_dequeue(&x25->interrupt_out_queue);
  129. x25_transmit_link(skb, x25->neighbour);
  130. }
  131. if (x25->condition & X25_COND_PEER_RX_BUSY)
  132. return;
  133. if (!skb_peek(&sk->sk_write_queue))
  134. return;
  135. modulus = x25->neighbour->extended ? X25_EMODULUS : X25_SMODULUS;
  136. start = skb_peek(&x25->ack_queue) ? x25->vs : x25->va;
  137. end = (x25->va + x25->facilities.winsize_out) % modulus;
  138. if (start == end)
  139. return;
  140. x25->vs = start;
  141. /*
  142. * Transmit data until either we're out of data to send or
  143. * the window is full.
  144. */
  145. skb = skb_dequeue(&sk->sk_write_queue);
  146. do {
  147. if ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
  148. skb_queue_head(&sk->sk_write_queue, skb);
  149. break;
  150. }
  151. skb_set_owner_w(skbn, sk);
  152. /*
  153. * Transmit the frame copy.
  154. */
  155. x25_send_iframe(sk, skbn);
  156. x25->vs = (x25->vs + 1) % modulus;
  157. /*
  158. * Requeue the original data frame.
  159. */
  160. skb_queue_tail(&x25->ack_queue, skb);
  161. } while (x25->vs != end &&
  162. (skb = skb_dequeue(&sk->sk_write_queue)) != NULL);
  163. x25->vl = x25->vr;
  164. x25->condition &= ~X25_COND_ACK_PENDING;
  165. x25_stop_timer(sk);
  166. }
  167. /*
  168. * The following routines are taken from page 170 of the 7th ARRL Computer
  169. * Networking Conference paper, as is the whole state machine.
  170. */
  171. void x25_enquiry_response(struct sock *sk)
  172. {
  173. struct x25_sock *x25 = x25_sk(sk);
  174. if (x25->condition & X25_COND_OWN_RX_BUSY)
  175. x25_write_internal(sk, X25_RNR);
  176. else
  177. x25_write_internal(sk, X25_RR);
  178. x25->vl = x25->vr;
  179. x25->condition &= ~X25_COND_ACK_PENDING;
  180. x25_stop_timer(sk);
  181. }